@davidwells/extract-deps 0.0.1

package/tests/get-imports.test.js

@@ -0,0 +1,395 @@
+const { test } = require('uvu') 
+const assert = require('uvu/assert')
+const { normalizeTestResult } = require('./test-utils')
+const { 
+  getImports,
+  getStaticImports, 
+  getTypeImports, 
+  getDynamicImports, 
+  getAssertionImports 
+} = require('../src/get-imports')
+
+test('Exports api', async () => {
+  assert.is(typeof getStaticImports, 'function', 'Exports api')
+  assert.is(typeof getTypeImports, 'function', 'Exports api')
+})
+
+test('getStaticImports', async () => {
+    const code = `
+  import {fileURLToPath, URL, whatever as funky} from 'url'
+  import foo from 'fs'
+  import * as Fs from 'fs'
+  import assert from 'uvu/assert'
+  const { test } = require('uvu')
+  const { getRequires } = require('./get-imports')
+    `
+
+    const importsFound = getStaticImports(code)
+    /*
+    console.log('importsFound')
+    deepLog(importsFound)
+    /** */
+    assert.equal(normalizeTestResult(importsFound), [
+    {
+      line: "import {fileURLToPath, URL, whatever as funky} from 'url'",
+      varType: 'const',
+      varName: '{fileURLToPath, URL, whatever as funky}',
+      definitions: {
+        expectsDestructuring: true,
+        declaration: '{fileURLToPath, URL, whatever as funky}',
+        destructuredParameters: [
+          { declaration: 'fileURLToPath', name: 'fileURLToPath' },
+          { declaration: 'URL', name: 'URL' },
+          {
+            declaration: 'whatever as funky',
+            name: 'whatever',
+            alias: 'funky'
+          }
+        ],
+        name: '{fileURLToPath, URL, whatever as funky}'
+      },
+      from: 'url',
+      isImport: true,
+      isRelative: false
+    },
+    {
+      line: "import foo from 'fs'",
+      varType: 'const',
+      varName: 'foo',
+      definitions: { declaration: 'foo', name: 'foo' },
+      from: 'fs',
+      isImport: true,
+      isRelative: false
+    },
+    {
+      line: "import * as Fs from 'fs'",
+      varType: 'const',
+      varName: '* as Fs',
+      definitions: { declaration: '* as Fs', name: '*', alias: 'Fs' },
+      from: 'fs',
+      isImport: true,
+      isRelative: false
+    },
+    {
+      line: "import assert from 'uvu/assert'",
+      varType: 'const',
+      varName: 'assert',
+      definitions: { declaration: 'assert', name: 'assert' },
+      from: 'uvu/assert',
+      isImport: true,
+      isRelative: false
+    }
+  ])
+})
+
+
+test('get jsDoc Imports', async () => {
+    const code = `
+    /**
+     * @param {string}   [fin="cool"]
+     * @param {import("./foo").hdhdhdhdhddh} [api] - lol
+     * @param {import("lodash").omit} Cool - lodash omit
+     * @param {import("uvu/assert")} Rad - other thing
+     */ 
+    `
+
+    const importsFound = getTypeImports(code)
+    /*
+    console.log('importsFound')
+    deepLog(importsFound)
+    /** */
+    assert.equal(normalizeTestResult(importsFound), [
+      {
+        importStatement: 'import("./foo").hdhdhdhdhddh',
+        importPath: './foo',
+        importName: 'hdhdhdhdhddh',
+        isImport: true,
+        isRelative: true
+      },
+      {
+        importStatement: 'import("lodash").omit',
+        importPath: 'lodash',
+        importName: 'omit',
+        isImport: true,
+        isRelative: false
+      },
+      {
+        importStatement: 'import("uvu/assert")',
+        importPath: 'uvu/assert',
+        importName: '',
+        isImport: true,
+        isRelative: false
+      }
+    ])
+})
+
+test('getDynamicImports', async () => {
+  const code = `
+  // Basic dynamic import with string literal
+  const module = await import('./module.js')
+  
+  // Dynamic import with variable
+  const moduleName = './utils.js'
+  const utils = await import(moduleName)
+  
+  // Dynamic import with template literal
+  const folder = 'components'
+  const component = await import(\`./src/\${folder}/Button.js\`)
+  
+  // Dynamic import with path building
+  const modulePath = path.join('./src', 'helpers', 'api.js')
+  const api = await import(modulePath)
+  
+  // Dynamic import with destructuring
+  const { default: Component, helper } = await import('./Component.js')
+  
+  // Dynamic import with function call
+  const dynamicModule = await import(getModulePath())
+  `
+
+  const importsFound = getDynamicImports(code)
+  /*
+  console.log('importsFound')
+  deepLog(importsFound)
+  /** */
+  assert.equal(importsFound.length, 6, 'Should find 6 dynamic imports')
+
+  assert.equal(normalizeTestResult(importsFound), [
+  {
+    line: "const module = await import('./module.js')",
+    varType: 'const',
+    varName: 'module',
+    definitions: { declaration: 'module', name: 'module' },
+    from: "'./module.js'",
+    isImport: true,
+    isRelative: true,
+    isDynamic: true
+  },
+  {
+    line: 'const utils = await import(moduleName)',
+    varType: 'const',
+    varName: 'utils',
+    definitions: { declaration: 'utils', name: 'utils' },
+    from: 'moduleName',
+    isImport: true,
+    isRelative: false,
+    isDynamic: true
+  },
+  {
+    line: 'const component = await import(`./src/${folder}/Button.js`)',
+    varType: 'const',
+    varName: 'component',
+    definitions: { declaration: 'component', name: 'component' },
+    from: '`./src/${folder}/Button.js`',
+    isImport: true,
+    isRelative: false,
+    isDynamic: true
+  },
+  {
+    line: 'const api = await import(modulePath)',
+    varType: 'const',
+    varName: 'api',
+    definitions: { declaration: 'api', name: 'api' },
+    from: 'modulePath',
+    isImport: true,
+    isRelative: false,
+    isDynamic: true
+  },
+  {
+    line: "const { default: Component, helper } = await import('./Component.js')",
+    varType: 'const',
+    varName: '{ default: Component, helper }',
+    definitions: {
+      expectsDestructuring: true,
+      declaration: '{ default: Component, helper }',
+      destructuredParameters: [
+        {
+          declaration: 'default: Component',
+          name: 'default',
+          alias: 'Component'
+        },
+        { declaration: 'helper', name: 'helper' }
+      ],
+      name: '{ default: Component, helper }'
+    },
+    from: "'./Component.js'",
+    isImport: true,
+    isRelative: true,
+    isDynamic: true
+  },
+  {
+    line: 'const dynamicModule = await import(getModulePath())',
+    varType: 'const',
+    varName: 'dynamicModule',
+    definitions: { declaration: 'dynamicModule', name: 'dynamicModule' },
+    from: 'getModulePath()',
+    isImport: true,
+    isRelative: false,
+    isDynamic: true
+  }
+])
+})
+
+test('Imports kitchen sink', () =>{
+  const code = `
+// Multi-line destructuring import
+import {
+  Component
+} from '@angular2/core';
+
+// Default import
+import defaultMember from "module-name";
+
+// Namespace import with extra spaces
+import   *    as name from "module-name  ";
+
+// Default import with missing quote
+import   React from react"
+
+// Destructuring import with extra spaces
+import   {  member }   from "  module-name";
+
+// Destructuring import with alias
+import { member as alias } from "module-name";
+
+// Multi-line destructuring import
+import { member1 , 
+member2 } from "module-name";
+
+// Multiple destructuring imports with aliases
+import { member1 , member2 as alias2 , member3 as alias3 } from "module-name";
+
+// Default import with destructuring
+import defaultMember, { member, member } from "module-name";
+
+// Default import with namespace
+import defaultMember, * as name from "module-name";
+
+// Side-effect import
+import "module-name";
+
+// Wildcard import
+import * from './smdn';
+`
+
+  const importsFound = normalizeTestResult(getImports(code))
+  
+  /*
+  console.log('importsFound')
+  deepLog(importsFound)
+
+  importsFound.forEach(item => {
+    console.log(item.line)
+  })
+  /** */
+
+  assert.equal(importsFound.length, 12, 'Imports found')
+})
+
+
+test('Assert imports', async () => {
+  const code = `
+// JSON assertion import
+import data from './data.json' assert { type: 'json' }
+
+// CSS assertion import
+import styles from './styles.css' assert { type: 'css' }
+
+// JSON assertion import with with keyword
+import dataTwo from './data-two.json' with { type: 'json' }
+
+// CSS assertion import with with keyword
+import styles from './styles.css' with { type: 'css' }
+  `
+
+  const importsFound = normalizeTestResult(getAssertionImports(code))
+  /*
+  console.log('assert importsFound')
+  deepLog(importsFound)
+  /** */
+
+  assert.equal(importsFound.length, 4, 'Should find 4 assertion imports')
+  
+  assert.equal(importsFound, [
+    {
+      line: "import data from './data.json' assert { type: 'json' }",
+      varType: 'const',
+      varName: 'data',
+      definitions: { declaration: 'data', name: 'data' },
+      from: './data.json',
+      assertion: "type: 'json'",
+      assertionType: 'assert',
+      isImport: true,
+      isRelative: true,
+      isAssertion: true
+    },
+    {
+      line: "import styles from './styles.css' assert { type: 'css' }",
+      varType: 'const',
+      varName: 'styles',
+      definitions: { declaration: 'styles', name: 'styles' },
+      from: './styles.css',
+      assertion: "type: 'css'",
+      assertionType: 'assert',
+      isImport: true,
+      isRelative: true,
+      isAssertion: true
+    },
+    {
+      line: "import dataTwo from './data-two.json' with { type: 'json' }",
+      varType: 'const',
+      varName: 'dataTwo',
+      definitions: { declaration: 'dataTwo', name: 'dataTwo' },
+      from: './data-two.json',
+      assertion: "type: 'json'",
+      assertionType: 'with',
+      isImport: true,
+      isRelative: true,
+      isAssertion: true
+    },
+    {
+      line: "import styles from './styles.css' with { type: 'css' }",
+      varType: 'const',
+      varName: 'styles',
+      definitions: { declaration: 'styles', name: 'styles' },
+      from: './styles.css',
+      assertion: "type: 'css'",
+      assertionType: 'with',
+      isImport: true,
+      isRelative: true,
+      isAssertion: true
+    }
+  ])
+})
+
+test('getImports with assertion imports', async () => {
+  const code = `
+// Regular import
+import foo from 'fs'
+
+// Assertion import
+import data from './data.json' assert { type: 'json' }
+
+// With import
+import styles from './styles.css' with { type: 'css' }
+  `
+
+  const importsFound = normalizeTestResult(getImports(code, { includeAssertionImports: true }))
+  /*
+  console.log('importsFound')
+  deepLog(importsFound)
+  /** */
+  
+  assert.equal(importsFound.length, 3, 'Should find 3 imports including assertion imports')
+  
+  // Check that we have all types of imports
+  const hasRegularImport = importsFound.some(imp => !imp.isAssertion && !imp.isDynamic)
+  const hasAssertImport = importsFound.some(imp => imp.isAssertion && imp.assertionType === 'assert')
+  const hasWithImport = importsFound.some(imp => imp.isAssertion && imp.assertionType === 'with')
+  
+  assert.is(hasRegularImport, true, 'Should have regular import')
+  assert.is(hasAssertImport, true, 'Should have assert import')
+  assert.is(hasWithImport, true, 'Should have with import')
+})
+
+test.run()

package/tests/get-requires.test.js

@@ -0,0 +1,201 @@
+const { test } = require('uvu') 
+const assert = require('uvu/assert')
+const { getRequires, getDynamicRequires } = require('../src/get-requires')
+const { normalizeTestResult } = require('./test-utils')
+
+test('Exports api', async () => {
+  assert.is(typeof getRequires, 'function', 'Exports getDocs')
+})
+
+test('getRequires', async () => {
+  const code = `
+  const { test } = require('uvu')
+  const assert = require('uvu/assert')
+  const { getRequires } = require('./get-imports')
+  `
+
+  const requiresFound = getRequires(code)
+  /*
+  console.log('requiresFound')
+  deepLog(requiresFound)
+  /** */
+  assert.equal(normalizeTestResult(requiresFound), [
+    {
+      line: "const { test } = require('uvu')",
+      varType: 'const',
+      varName: '{ test }',
+      definitions: {
+        expectsDestructuring: true,
+        declaration: '{ test }',
+        destructuredParameters: [ { declaration: 'test', name: 'test' } ],
+        name: '{ test }'
+      },
+      from: 'uvu',
+      isRequire: true,
+      isRelative: false,
+      isDynamic: false
+    },
+    {
+      line: "const assert = require('uvu/assert')",
+      varType: 'const',
+      varName: 'assert',
+      definitions: { declaration: 'assert', name: 'assert' },
+      from: 'uvu/assert',
+      isRequire: true,
+      isRelative: false,
+      isDynamic: false
+    },
+    {
+      line: "const { getRequires } = require('./get-imports')",
+      varType: 'const',
+      varName: '{ getRequires }',
+      definitions: {
+        expectsDestructuring: true,
+        declaration: '{ getRequires }',
+        destructuredParameters: [ { declaration: 'getRequires', name: 'getRequires' } ],
+        name: '{ getRequires }'
+      },
+      from: './get-imports',
+      isRequire: true,
+      isRelative: true,
+      isDynamic: false
+    }
+  ])
+})
+
+test('getRequires 2', async () => {
+  const code = `
+  const { test : funky, foo = false } = require('uvu')
+  const assert = require('uvu/assert')
+  const { getRequires } = require('./get-imports')
+  `
+  const requiresFound = getRequires(code)
+  /*
+  console.log('requiresFound')
+  deepLog(requiresFound)
+  /** */
+
+  assert.equal(normalizeTestResult(requiresFound), [
+    {
+      line: "const { test : funky, foo = false } = require('uvu')",
+      varType: 'const',
+      varName: '{ test : funky, foo = false }',
+      definitions: {
+        expectsDestructuring: true,
+        declaration: '{ test : funky, foo = false }',
+        destructuredParameters: [
+          { declaration: 'test : funky', name: 'test', alias: 'funky' },
+          {
+            defaultValue: 'false',
+            declaration: 'foo = false',
+            name: 'foo'
+          }
+        ],
+        name: '{ test : funky, foo = false }'
+      },
+      from: 'uvu',
+      isRequire: true,
+      isRelative: false,
+      isDynamic: false
+    },
+    {
+      line: "const assert = require('uvu/assert')",
+      varType: 'const',
+      varName: 'assert',
+      definitions: { declaration: 'assert', name: 'assert' },
+      from: 'uvu/assert',
+      isRequire: true,
+      isRelative: false,
+      isDynamic: false
+    },
+    {
+      line: "const { getRequires } = require('./get-imports')",
+      varType: 'const',
+      varName: '{ getRequires }',
+      definitions: {
+        expectsDestructuring: true,
+        declaration: '{ getRequires }',
+        destructuredParameters: [ { declaration: 'getRequires', name: 'getRequires' } ],
+        name: '{ getRequires }'
+      },
+      from: './get-imports',
+      isRequire: true,
+      isRelative: true,
+      isDynamic: false
+    }
+  ])
+})
+
+test('getRequires with dynamic requires', async () => {
+  const code = `
+  const moduleName = 'fs'
+  const dynamicRequire = require(moduleName)
+  const path = require('path')
+  const dynamicPath = require(path.join(__dirname, 'utils'))
+  const foo = require('foo-pkg')
+  require(\`./$\{folder}/file\`)
+  const { test : funky, foo = false } = require(moduleTwo)
+  `
+
+  const requiresFound = getDynamicRequires(code)
+  /*
+  console.log('requiresFound')
+  deepLog(requiresFound)
+  /** */
+  assert.equal(normalizeTestResult(requiresFound), [
+    {
+      line: 'const dynamicRequire = require(moduleName)',
+      varType: 'const',
+      varName: 'dynamicRequire',
+      definitions: { declaration: 'dynamicRequire', name: 'dynamicRequire' },
+      from: 'moduleName',
+      isRequire: true,
+      isRelative: false,
+      isDynamic: true
+    },
+    {
+      line: "const dynamicPath = require(path.join(__dirname, 'utils'))",
+      varType: 'const',
+      varName: 'dynamicPath',
+      definitions: { declaration: 'dynamicPath', name: 'dynamicPath' },
+      from: "path.join(__dirname, 'utils')",
+      isRequire: true,
+      isRelative: false,
+      isDynamic: true
+    },
+    {
+      line: 'require(`./${folder}/file`)',
+      varType: '',
+      varName: '',
+      definitions: null,
+      from: '`./${folder}/file`',
+      isRequire: true,
+      isRelative: false,
+      isDynamic: true
+    },
+    {
+      line: 'const { test : funky, foo = false } = require(moduleTwo)',
+      varType: 'const',
+      varName: '{ test : funky, foo = false }',
+      definitions: {
+        expectsDestructuring: true,
+        declaration: '{ test : funky, foo = false }',
+        destructuredParameters: [
+          { declaration: 'test : funky', name: 'test', alias: 'funky' },
+          {
+            defaultValue: 'false',
+            declaration: 'foo = false',
+            name: 'foo'
+          }
+        ],
+        name: '{ test : funky, foo = false }'
+      },
+      from: 'moduleTwo',
+      isRequire: true,
+      isRelative: false,
+      isDynamic: true
+    }
+  ])
+})
+
+test.run()