@davidwells/extract-deps 0.0.1

package/tests/index.test.js

@@ -0,0 +1,202 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const path = require('path')
+const fs = require('fs')
+
+// Relative requires for local packages
+const { getPackagesList } = require('../../packages-list/index.js')
+const { extractDeps, getImports, getRequires } = require('../src/index.js')
+
+/**
+ * @typedef {Object} PackageDeps
+ * @property {string} name - Package name
+ * @property {string} mainFile - Path to main file
+ * @property {Object} deps - Extracted dependencies
+ * @property {Array} deps.imports - Import statements found
+ * @property {Array} deps.requires - Require statements found
+ */
+
+/**
+ * Reads the main file content for a package
+ * @param {Object} pkg - Package object from getPackagesList
+ * @returns {Promise<string>} File content
+ */
+async function readMainFile(pkg) {
+  const mainFile = pkg.pkg.main || 'index.js'
+  const fullPath = path.join(pkg.dir.full, mainFile)
+  
+  try {
+    return await fs.promises.readFile(fullPath, 'utf-8')
+  } catch (error) {
+    console.log(error)
+    console.log(pkg)
+    console.log(`Could not read main file for ${pkg.name}: ${fullPath}`)
+    return ''
+  }
+}
+
+/**
+ * Extracts dependencies from all packages in the lerna fixture
+ * @returns {Promise<PackageDeps[]>} Array of package dependencies
+ */
+async function extractAllPackageDeps() {
+  const fixturePath = path.join(__dirname, '../../packages-build-order/tests/lerna-fixture')
+  const packages = await getPackagesList(fixturePath, { excludeRoot: true })
+  //console.log('packages', packages)
+  
+  const results = []
+  
+  for (const pkg of packages) {
+    const mainFileContent = await readMainFile(pkg)
+    
+    if (mainFileContent) {
+      const deps = extractDeps(mainFileContent)
+      const mainFile = pkg.pkg.main || 'index.js'
+      
+      results.push({
+        name: pkg.name,
+        mainFile: path.join(pkg.dir.relative, mainFile),
+        deps: deps
+      })
+    }
+  }
+  
+  return results
+}
+
+test('should extract dependencies from lerna fixture packages', async () => {
+  const packageDeps = await extractAllPackageDeps()
+
+  
+  // Should have found packages
+  assert.ok(packageDeps.length > 0, 'Should find packages in fixture')
+  
+  /*
+  console.log('packageDeps', packageDeps)
+  // Log results for inspection
+  console.log('\n=== Package Dependencies Found ===')
+  packageDeps.forEach(pkg => {
+    console.log(`\n📦 ${pkg.name} (${pkg.mainFile}):`)
+    
+    if (pkg.deps.imports.length > 0) {
+      console.log('  📥 Imports:')
+      pkg.deps.imports.forEach(imp => {
+        console.log(`    - ${imp.from || imp.moduleSpecifier}`)
+      })
+    }
+    
+    if (pkg.deps.requires.length > 0) {
+      console.log('  📥 Requires:')
+      pkg.deps.requires.forEach(req => {
+        console.log(`    - ${req.from}`)
+      })
+    }
+    
+    if (pkg.deps.imports.length === 0 && pkg.deps.requires.length === 0) {
+      console.log('  📥 No imports/requires found')
+    }
+  })
+  /** */
+  // Specific assertions for known packages
+  const usagePackage = packageDeps.find(pkg => pkg.name === 'testing-lerna-usage')
+  assert.ok(usagePackage, 'Should find testing-lerna-usage package')
+  
+  if (usagePackage) {
+    assert.ok(usagePackage.deps.requires.length > 0, 'testing-lerna-usage should have requires')
+    
+    const requireModules = usagePackage.deps.requires.map(req => req.from)
+    assert.ok(requireModules.includes('testing-lerna-one'), 'Should require testing-lerna-one')
+    assert.ok(requireModules.includes('testing-lerna-two'), 'Should require testing-lerna-two')
+  }
+  
+  // Check that packages without dependencies are handled correctly
+  const onePackage = packageDeps.find(pkg => pkg.name === 'testing-lerna-one')
+  assert.ok(onePackage, 'Should find testing-lerna-one package')
+  
+  if (onePackage) {
+    // testing-lerna-one should have no imports/requires (just exports)
+    assert.ok(onePackage.deps.imports.length === 0, 'testing-lerna-one should have no imports')
+    assert.ok(onePackage.deps.requires.length === 0, 'testing-lerna-one should have no requires')
+  }
+})
+
+test('should handle packages with different main file locations', async () => {
+  const fixturePath = path.join(__dirname, '../../packages-build-order/tests/lerna-fixture')
+  const packages = await getPackagesList(fixturePath, { excludeRoot: true })
+  
+  // Find packages with different main file configurations
+  const packagesWithMain = packages.filter(pkg => pkg.pkg.main)
+  const packagesWithoutMain = packages.filter(pkg => !pkg.pkg.main)
+  
+  /*
+  console.log('\n=== Main File Analysis ===')
+  console.log(`Packages with explicit main: ${packagesWithMain.length}`)
+  console.log(`Packages using default index.js: ${packagesWithoutMain.length}`)
+  /** */
+  // Verify we can read both types
+  for (const pkg of packagesWithMain) {
+    const content = await readMainFile(pkg)
+    assert.ok(content !== undefined, `Should be able to read main file for ${pkg.name}`)
+  }
+  
+  for (const pkg of packagesWithoutMain) {
+    const content = await readMainFile(pkg)
+    assert.ok(content !== undefined, `Should be able to read default index.js for ${pkg.name}`)
+  }
+})
+
+test('should extract specific import/require patterns', async () => {
+  const fixturePath = path.join(__dirname, '../../packages-build-order/tests/lerna-fixture')
+  const packages = await getPackagesList(fixturePath)
+  
+  // Find the usage package which has known require patterns
+  const usagePackage = packages.find(pkg => pkg.name === 'testing-lerna-usage')
+  assert.ok(usagePackage, 'Should find testing-lerna-usage package')
+  
+  const mainFileContent = await readMainFile(usagePackage)
+  const deps = extractDeps(mainFileContent)
+  
+  /*
+  console.log('\n=== Detailed Import/Require Analysis ===')
+  console.log('testing-lerna-usage dependencies:')
+  console.log('Requires:', deps.requires)
+  console.log('Imports:', deps.imports)
+  /** */
+
+  // Test specific require patterns
+  assert.ok(deps.requires.length === 2, 'Should have 2 require statements')
+  
+  const requireModules = deps.requires.map(req => req.from)
+  assert.ok(requireModules.includes('testing-lerna-one'), 'Should require testing-lerna-one')
+  assert.ok(requireModules.includes('testing-lerna-two'), 'Should require testing-lerna-two')
+  
+  // Test that no imports are found (since this package uses require)
+  assert.ok(deps.imports.length === 0, 'Should have no import statements')
+})
+
+test('should handle packages with no dependencies gracefully', async () => {
+  const fixturePath = path.join(__dirname, '../../packages-build-order/tests/lerna-fixture')
+  const packages = await getPackagesList(fixturePath)
+  
+  // Find packages that should have no dependencies
+  const simplePackages = packages.filter(pkg => 
+    ['testing-lerna-one', 'testing-lerna-two'].includes(pkg.name)
+  )
+  
+  for (const pkg of simplePackages) {
+    const mainFileContent = await readMainFile(pkg)
+    const deps = extractDeps(mainFileContent)
+    
+    /*
+    console.log(`\n${pkg.name} dependencies:`, {
+      imports: deps.imports.length,
+      requires: deps.requires.length
+    })
+    /** */
+    // These packages should have no imports or requires
+    assert.ok(deps.imports.length === 0, `${pkg.name} should have no imports`)
+    assert.ok(deps.requires.length === 0, `${pkg.name} should have no requires`)
+  }
+})
+
+test.run()

package/tests/test-utils.js

@@ -0,0 +1,30 @@
+const util = require('util')
+
+/**
+ * Normalizes test results by removing the `index` field from import/require objects
+ * This is useful for testing since index values can vary and aren't part of the core functionality
+ * @param {Array|Object} result - The result object or array of result objects to normalize
+ * @returns {Array|Object} - The normalized result with index fields removed
+ */
+function normalizeTestResult(result) {
+  if (Array.isArray(result)) {
+    return result.map(item => normalizeTestResult(item))
+  }
+  
+  if (result && typeof result === 'object') {
+    const normalized = { ...result }
+    delete normalized.index
+    return normalized
+  }
+  
+  return result
+}
+
+function deepLog(myObject) {
+  console.log(util.inspect(myObject, {showHidden: false, depth: null, colors: true}))
+}
+
+module.exports = {
+  normalizeTestResult,
+  deepLog
+} 

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "declarationMap": true,
+    "strict": false,
+    "noImplicitAny": false,
+    "strictNullChecks": false,
+    "allowSyntheticDefaultImports": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "target": "ES2020",
+    "module": "CommonJS"
+  },
+  "include": ["src/**/*.js", "src/**/*.ts"],
+  "exclude": ["node_modules", "types"]
+}

package/types/detect-syntax.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Options for detecting syntax within a code string.
+ */
+export type DetectSyntaxOptions = {
+    /**
+     * - Indicates whether comments should be stripped from the code before syntax checking.
+     */
+    stripComments?: boolean;
+};
+/**
+ * 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`.
+ */
+export function hasESMSyntax(code: string, opts?: DetectSyntaxOptions): boolean;
+/**
+ * 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.
+ */
+export function hasCJSSyntax(code: string, opts?: DetectSyntaxOptions): boolean;
+/**
+ * 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`).
+ */
+export function detectSyntax(code: string, opts?: DetectSyntaxOptions): any;
+//# sourceMappingURL=detect-syntax.d.ts.map

package/types/detect-syntax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-syntax.d.ts","sourceRoot":"","sources":["../src/detect-syntax.js"],"names":[],"mappings":";;;;;;;oBAec,OAAO;;AAHrB;;;;GAIG;AAEH;;;;;;GAMG;AACH,mCAJW,MAAM,SACN,mBAAmB,GACjB,OAAO,CAMnB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,SACN,mBAAmB,GACjB,OAAO,CAMnB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,SACN,mBAAmB,OAe7B"}

package/types/extract-deps/_usage.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Analyze dependencies in the lerna fixture
+ */
+export function analyzeLernaFixture(): void;
+/**
+ * Example of using extractDeps with actual code files
+ */
+export function analyzeCodeDependencies(): void;
+/**
+ * Read and parse a package.json file
+ * @param {string} filePath - Path to the package.json file
+ * @returns {Object} Parsed package.json content
+ */
+export function readPackageJson(filePath: string): any;
+/**
+ * Get all package.json files in the lerna fixture
+ * @returns {Array} Array of package.json file paths
+ */
+export function getPackageJsonFiles(): any[];
+//# sourceMappingURL=_usage.d.ts.map

package/types/extract-deps/_usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_usage.d.ts","sourceRoot":"","sources":["../../_usage.js"],"names":[],"mappings":"AAuDA;;GAEG;AACH,4CA8BC;AAED;;GAEG;AACH,gDA4CC;AA7HD;;;;GAIG;AACH,0CAHW,MAAM,OAWhB;AAED;;;GAGG;AACH,6CAsBC"}

package/types/extract-deps/examples/get-exports.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-exports.d.ts.map

package/types/extract-deps/examples/get-exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-exports.d.ts","sourceRoot":"","sources":["../../../examples/get-exports.js"],"names":[],"mappings":""}

package/types/extract-deps/src/detect-syntax.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Options for detecting syntax within a code string.
+ */
+export type DetectSyntaxOptions = {
+    /**
+     * - Indicates whether comments should be stripped from the code before syntax checking.
+     */
+    stripComments?: boolean;
+};
+/**
+ * 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`.
+ */
+export function hasESMSyntax(code: string, opts?: DetectSyntaxOptions): boolean;
+/**
+ * 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.
+ */
+export function hasCJSSyntax(code: string, opts?: DetectSyntaxOptions): boolean;
+/**
+ * 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`).
+ */
+export function detectSyntax(code: string, opts?: DetectSyntaxOptions): any;
+//# sourceMappingURL=detect-syntax.d.ts.map

package/types/extract-deps/src/detect-syntax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-syntax.d.ts","sourceRoot":"","sources":["../../../src/detect-syntax.js"],"names":[],"mappings":";;;;;;;oBAec,OAAO;;AAHrB;;;;GAIG;AAEH;;;;;;GAMG;AACH,mCAJW,MAAM,SACN,mBAAmB,GACjB,OAAO,CAMnB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,SACN,mBAAmB,GACjB,OAAO,CAMnB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,SACN,mBAAmB,OAe7B"}

package/types/extract-deps/src/get-exports.d.ts

@@ -0,0 +1,52 @@
+export function getExports(code: any, options?: {}): any[];
+export function getDefaultExports(targetText?: string): {
+    line: string;
+    exportType: string;
+    exportName: any;
+    exportValue: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getNamedExports(targetText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getNamedDeclarationExports(targetText?: string): any[];
+export function getAllExports(targetText?: string): {
+    line: string;
+    exportType: string;
+    from: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getNamespaceExports(targetText?: string): {
+    line: string;
+    exportType: string;
+    namespace: string;
+    from: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getTypeExports(targetText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getAssertionExports(targetText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    definitions: any;
+    from: string;
+    assertion: string;
+    assertionType: string;
+    index: number;
+    isExport: boolean;
+    isAssertion: boolean;
+}[];
+//# sourceMappingURL=get-exports.d.ts.map

package/types/extract-deps/src/get-exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-exports.d.ts","sourceRoot":"","sources":["../../../src/get-exports.js"],"names":[],"mappings":"AAiBA,2DAsBC;AAED;;;;;;;IA4BC;AAED;;;;;;IAeC;AAED,uEAmBC;AAED;;;;;;IAeC;AAED;;;;;;;IAgBC;AAED;;;;;;IAeC;AAED;;;;;;;;;;;IAuBC"}

package/types/extract-deps/src/get-imports.d.ts

@@ -0,0 +1,53 @@
+export function getImports(code: any, options?: {}): {
+    line: string;
+    varType: string;
+    varName: string;
+    definitions: any;
+    from: string;
+    index: number;
+    isImport: boolean;
+    isRelative: boolean;
+}[];
+export function getStaticImports(targetText?: string): {
+    line: string;
+    varType: string;
+    varName: string;
+    definitions: any;
+    from: string;
+    index: number;
+    isImport: boolean;
+    isRelative: boolean;
+}[];
+export function getTypeImports(targetText?: string): {
+    importStatement: string;
+    importPath: string;
+    importName: string;
+    index: number;
+    isImport: boolean;
+    isRelative: boolean;
+}[];
+export function getDynamicImports(targetText?: string): {
+    line: string;
+    varType: string;
+    varName: string;
+    definitions: any;
+    from: string;
+    index: number;
+    isImport: boolean;
+    isRelative: boolean;
+    isDynamic: boolean;
+}[];
+export function getAssertionImports(targetText?: string): {
+    line: string;
+    varType: string;
+    varName: string;
+    definitions: any;
+    from: string;
+    assertion: string;
+    assertionType: string;
+    index: number;
+    isImport: boolean;
+    isRelative: boolean;
+    isAssertion: boolean;
+}[];
+//# sourceMappingURL=get-imports.d.ts.map

package/types/extract-deps/src/get-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-imports.d.ts","sourceRoot":"","sources":["../../../src/get-imports.js"],"names":[],"mappings":"AAWA;;;;;;;;;IAQC;AAGD;;;;;;;;;IAkBC;AAED;;;;;;;IAgBC;AAED;;;;;;;;;;IAoBC;AAED;;;;;;;;;;;;IAwBC"}

package/types/extract-deps/src/get-requires.d.ts

@@ -0,0 +1,34 @@
+export function getRequires(code: any): {
+    line: string;
+    varType: string;
+    varName: string;
+    definitions: any;
+    from: string;
+    index: number;
+    isRequire: boolean;
+    isRelative: boolean;
+    isDynamic: boolean;
+}[];
+export function getStaticRequires(targetText?: string): {
+    line: string;
+    varType: string;
+    varName: string;
+    definitions: any;
+    from: string;
+    index: number;
+    isRequire: boolean;
+    isRelative: boolean;
+    isDynamic: boolean;
+}[];
+export function getDynamicRequires(code: any): {
+    line: string;
+    varType: string;
+    varName: string;
+    definitions: any;
+    from: string;
+    index: number;
+    isRequire: boolean;
+    isRelative: boolean;
+    isDynamic: boolean;
+}[];
+//# sourceMappingURL=get-requires.d.ts.map

package/types/extract-deps/src/get-requires.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-requires.d.ts","sourceRoot":"","sources":["../../../src/get-requires.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;IAIC;AA5BD;;;;;;;;;;IAsBC;AArDD;;;;;;;;;;IA4BC"}

package/types/extract-deps/src/index.d.ts

@@ -0,0 +1,39 @@
+export function extractDeps(code: any): {
+    imports: {
+        line: string;
+        varType: string;
+        varName: string;
+        definitions: any;
+        from: string;
+        index: number;
+        isImport: boolean;
+        isRelative: boolean;
+    }[];
+    requires: {
+        line: string;
+        varType: string;
+        varName: string;
+        definitions: any;
+        from: string;
+        index: number;
+        isRequire: boolean;
+        isRelative: boolean;
+        isDynamic: boolean;
+    }[];
+    exports: any[];
+};
+import { getRequires } from "./get-requires";
+import { getDynamicRequires } from "./get-requires";
+import { getStaticRequires } from "./get-requires";
+import { getImports } from "./get-imports";
+import { getStaticImports } from "./get-imports";
+import { getDynamicImports } from "./get-imports";
+import { getExports } from "./get-exports";
+import { getDefaultExports } from "./get-exports";
+import { getNamedExports } from "./get-exports";
+import { getNamedDeclarationExports } from "./get-exports";
+import { getAllExports } from "./get-exports";
+import { getNamespaceExports } from "./get-exports";
+import { getTypeExports } from "./get-exports";
+export { getRequires, getDynamicRequires, getStaticRequires, getImports, getStaticImports, getDynamicImports, getExports, getDefaultExports, getNamedExports, getNamedDeclarationExports, getAllExports, getNamespaceExports, getTypeExports };
+//# sourceMappingURL=index.d.ts.map

package/types/extract-deps/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;EAQC"}

package/types/extract-deps/src/utils.d.ts

@@ -0,0 +1,4 @@
+export function isRelativeImport(importLocation: any): boolean;
+export function isRelativeImportWithQuotes(importLocation: any): boolean;
+export function getNames(names?: any[]): any;
+//# sourceMappingURL=utils.d.ts.map

package/types/extract-deps/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/utils.js"],"names":[],"mappings":"AAEA,+DAEC;AAED,yEAKC;AAED,6CA2CC"}

package/types/extract-deps/tests/detect-syntax.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=detect-syntax.test.d.ts.map

package/types/extract-deps/tests/detect-syntax.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-syntax.test.d.ts","sourceRoot":"","sources":["../../../tests/detect-syntax.test.js"],"names":[],"mappings":""}

package/types/extract-deps/tests/get-exports.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-exports.test.d.ts.map

package/types/extract-deps/tests/get-exports.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-exports.test.d.ts","sourceRoot":"","sources":["../../../tests/get-exports.test.js"],"names":[],"mappings":""}

package/types/extract-deps/tests/get-imports.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-imports.test.d.ts.map

package/types/extract-deps/tests/get-imports.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-imports.test.d.ts","sourceRoot":"","sources":["../../../tests/get-imports.test.js"],"names":[],"mappings":""}

package/types/extract-deps/tests/get-requires.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-requires.test.d.ts.map

package/types/extract-deps/tests/get-requires.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-requires.test.d.ts","sourceRoot":"","sources":["../../../tests/get-requires.test.js"],"names":[],"mappings":""}

package/types/extract-deps/tests/index.test.d.ts

@@ -0,0 +1,18 @@
+export type PackageDeps = {
+    /**
+     * - Package name
+     */
+    name: string;
+    /**
+     * - Path to main file
+     */
+    mainFile: string;
+    /**
+     * - Extracted dependencies
+     */
+    deps: {
+        imports: any[];
+        requires: any[];
+    };
+};
+//# sourceMappingURL=index.test.d.ts.map

package/types/extract-deps/tests/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../tests/index.test.js"],"names":[],"mappings":";;;;UAWc,MAAM;;;;cACN,MAAM;;;;;QAEM,OAAO;QACP,QAAQ"}

package/types/extract-deps/tests/test-utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Normalizes test results by removing the `index` field from import/require objects
+ * This is useful for testing since index values can vary and aren't part of the core functionality
+ * @param {Array|Object} result - The result object or array of result objects to normalize
+ * @returns {Array|Object} - The normalized result with index fields removed
+ */
+export function normalizeTestResult(result: any[] | any): any[] | any;
+export function deepLog(myObject: any): void;
+//# sourceMappingURL=test-utils.d.ts.map

package/types/extract-deps/tests/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../../tests/test-utils.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,4CAHW,WAAY,GACV,WAAY,CAcxB;AAED,6CAEC"}