@davidwells/extract-deps 0.0.3 → 0.0.5

package/tests/get-exports.test.js

@@ -23,40 +23,51 @@ export default () => {}
   `
   
   const foundExports = getDefaultExports(code)
+  console.log('foundExports', foundExports)
 
-  assert.ok(foundExports.length === 6, 'Should find 6 default exports')
+  assert.ok(foundExports.length === 7, 'Should find 7 default exports')
 
   // Check function export
-  const functionExport = foundExports.find(exp => exp.exportName === 'myFunction')
+  const functionExport = foundExports.find(exp => exp.exportDefinitionName === 'myFunction')
   assert.ok(functionExport, 'Should find function export')
   assert.equal(functionExport.exportType, 'default')
-  assert.equal(functionExport.exportValue, 'function myFunction')
+  assert.equal(functionExport.exportValue, 'function myFunction() {}')
 
   // Check class export
-  const classExport = foundExports.find(exp => exp.exportName === 'MyClass')
+  const classExport = foundExports.find(exp => exp.exportDefinitionName === 'MyClass')
   assert.ok(classExport, 'Should find class export')
   assert.equal(classExport.exportType, 'default')
-  assert.equal(classExport.exportValue, 'class MyClass')
+  assert.equal(classExport.exportValue, 'class MyClass {}')
 
   // Check object literal
-  const objectExport = foundExports.find(exp => exp.exportName === 'literal')
+  const objectExport = foundExports.find(exp => exp.exportDefinitionName === 'literal-object')
   assert.ok(objectExport, 'Should find object literal export')
   assert.equal(objectExport.exportValue, "{ foo: 'bar' }")
+  assert.equal(objectExport.exportName, '')
+
+  // Check string literal
+  const stringExport = foundExports.find(exp => exp.exportDefinitionName === 'literal-string')
+  assert.ok(stringExport, 'Should find string literal export')
+  assert.equal(stringExport.exportValue, "'hello'", 'exportValue should be "hello"')
+  assert.equal(stringExport.exportName, '', 'exportName should be empty')
 
   // Check array literal
   const arrayExport = foundExports.find(exp => exp.exportValue === '[1, 2, 3]')
   assert.ok(arrayExport, 'Should find array literal export')
-  assert.equal(arrayExport.exportName, 'literal')
+  assert.equal(arrayExport.exportDefinitionName, 'literal-array')
+  assert.equal(arrayExport.exportName, '')
 
   // Check number literal
   const numberExport = foundExports.find(exp => exp.exportValue === '42')
   assert.ok(numberExport, 'Should find number literal export')
-  assert.equal(numberExport.exportName, '42')
+  assert.equal(numberExport.exportDefinitionName, 'literal-number')
+  assert.equal(numberExport.exportName, '')
 
   // Check arrow function
   const arrowExport = foundExports.find(exp => exp.exportValue === '() =>')
   assert.ok(arrowExport, 'Should find arrow function export')
-  assert.equal(arrowExport.exportName, 'anonymous')
+  assert.equal(arrowExport.exportDefinitionName, 'anonymous')
+  assert.equal(arrowExport.exportName, '')
 })
 
 test('should extract named exports', () => {
@@ -318,7 +329,7 @@ export {
   assert.ok(foundExports.length > 0, 'Should find exports in complex code')
 
   // Should handle anonymous functions and classes
-  const anonymousExports = foundExports.filter(exp => exp.exportName === 'anonymous')
+  const anonymousExports = foundExports.filter(exp => exp.exportDefinitionName === 'anonymous')
   assert.ok(anonymousExports.length >= 2, 'Should find anonymous function and class exports')
 
   // Should handle complex named declaration exports
@@ -380,4 +391,145 @@ export { MyComponent, Button, Input }
   assert.ok(thirdExport.exportType === 'named', 'Should find named export')
 })
 
+
+test('lambda function default function', () => {
+  const code = `
+const handler = async event => {
+  return {
+    statusCode: 200,
+    body: JSON.stringify(
+      {
+        message: 'yo function',
+        input: event,
+      },
+      null,
+      2
+    ),
+  };
+};
+export default handler
+  `
+
+  const foundExports = getExports(code)
+  console.log('foundExports', foundExports)
+
+  // TODO add assertions
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.ok(foundExports[0].exportType, 'Should have exportType array')
+  assert.equal(foundExports[0].exportType, 'default', 'exportType should be default')
+  assert.equal(foundExports[0].exportName, '', 'exportName should empty because it default function')
+})
+
+
+test('lambda function default function inline', () => {
+  const code = `
+export default async function handler(event) {
+  return {
+    statusCode: 200,
+    body: JSON.stringify({
+      message: 'yo function',
+      input: event,
+    }, null, 2),
+  }
+}
+  `
+
+  const foundExports = getExports(code)
+  console.log('foundExports', foundExports)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.ok(foundExports[0].exportType, 'Should have keys array')
+  assert.equal(foundExports[0].exportType, 'default', 'exportType should be default')
+  assert.equal(foundExports[0].exportName, '', 'exportName should empty because it default function')
+})
+
+test('lambda function default object', () => {
+  const code = `
+const handler = async event => {
+  return {
+    statusCode: 200,
+    body: JSON.stringify(
+      {
+        message: 'yo function',
+        input: event,
+      },
+      null,
+      2
+    ),
+  };
+};
+export default {
+  handler,
+}
+  `
+
+  const foundExports = getExports(code)
+  console.log('foundExports', foundExports)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.ok(foundExports[0].keys, 'Should have keys array')
+  assert.equal(foundExports[0].keys.length, 1, 'Should have 1 key')
+  assert.equal(foundExports[0].keys[0], 'handler', 'Key should be "handler" without trailing comma')
+})
+
+
+test('lambda function named object', () => {
+  const code = `
+const handler = async event => {
+  return {
+    statusCode: 200,
+    body: JSON.stringify(
+      {
+        message: 'yo function',
+        input: event,
+      },
+      null,
+      2
+    ),
+  };
+};
+export {
+  handler,
+}
+  `
+
+  const foundExports = getExports(code)
+  console.log('foundExports', foundExports)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.ok(foundExports[0].exportType, 'Should have keys array')
+  assert.equal(foundExports[0].exportType, 'named', 'exportType should be named')
+  assert.equal(foundExports[0].exportName, 'handler', 'exportName should be "handler" without trailing comma')
+})
+
+test('lambda function named object with alias', () => {
+  const code = `
+const handler = async event => {
+  return {
+    statusCode: 200,
+    body: JSON.stringify(
+      {
+        message: 'yo function',
+        input: event,
+      },
+      null,
+      2
+    ),
+  };
+};
+export {
+  handler as myHandler
+}
+  `
+
+  const foundExports = getExports(code)
+  console.log('foundExports', foundExports)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.ok(foundExports[0].exportType, 'Should have keys array')
+  assert.equal(foundExports[0].exportType, 'named', 'exportType should be named')
+  assert.equal(foundExports[0].exportName, 'handler', 'exportName should be "handler" without trailing comma')
+  assert.equal(foundExports[0].exportAlias, 'myHandler', 'exportAlias should be "myHandler" without trailing comma')
+})
+
 test.run() 

package/types/dep-graph.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Build dependency graph for a file and its dependencies
+ * @param {string} filePath - File to analyze
+ * @param {object} options - Options
+ * @param {boolean} [options.buildGraph] - If true, build and return dependency graph. Default: true
+ * @param {boolean} [options.verifyGraph] - If true, verify imports/exports. Default: true
+ * @param {boolean} [options.throwOnFirstError] - If true, throw immediately on first error. Default: false
+ * @returns {Map<string, string[]>|undefined} - Dependency graph where keys are file paths and values are arrays of dependency paths. Returns undefined if buildGraph is false.
+ */
+export function depGraph(filePath: string, options?: {
+    buildGraph?: boolean;
+    verifyGraph?: boolean;
+    throwOnFirstError?: boolean;
+}): Map<string, string[]> | undefined;
+/**
+ * Get all dependency file paths in build order (dependencies first), deduplicated
+ * @param {string} filePath - Entry file path
+ * @param {object} options - Options to pass to depGraph
+ * @returns {string[]} - Array of unique dependency file paths in topological order
+ */
+export function resolveDepPaths(filePath: string, options?: object): string[];
+//# sourceMappingURL=dep-graph.d.ts.map

package/types/dep-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dep-graph.d.ts","sourceRoot":"","sources":["../src/dep-graph.js"],"names":[],"mappings":"AA+LA;;;;;;;;GAQG;AACH,mCAPW,MAAM;IAEY,UAAU,GAA5B,OAAO;IACW,WAAW,GAA7B,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACL,IAAI,MAAM,EAAE,MAAM,EAAE,CAAC,GAAC,SAAS,CAiB3C;AAGD;;;;;GAKG;AACH,0CAJW,MAAM,YACN,MAAM,GACJ,MAAM,EAAE,CAsCpB"}

package/types/get-cjs-exports.d.ts

@@ -0,0 +1,35 @@
+export function getCjsExports(code: any): any[];
+export function getModuleExportsAssignment(originalText?: string, sanitizedText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportDefinitionName: any;
+    exportValue: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getModuleExportsProperty(originalText?: string, sanitizedText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportValue: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getExportsProperty(originalText?: string, sanitizedText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportValue: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getObjectAssignExports(originalText?: string, sanitizedText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportValue: string;
+    index: number;
+    isExport: boolean;
+}[];
+//# sourceMappingURL=get-cjs-exports.d.ts.map

package/types/get-cjs-exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-cjs-exports.d.ts","sourceRoot":"","sources":["../src/get-cjs-exports.js"],"names":[],"mappings":"AA+BA,gDAuBC;AA+BD;;;;;;;;IAqGC;AAED;;;;;;;IAqBC;AAED;;;;;;;IAqBC;AAED;;;;;;;IAiDC"}

package/types/get-exports.d.ts

@@ -2,7 +2,8 @@ export function getExports(code: any, options?: {}): any[];
 export function getDefaultExports(targetText?: string): {
     line: string;
     exportType: string;
-    exportName: any;
+    exportName: string;
+    exportDefinitionName: any;
     exportValue: string;
     index: number;
     isExport: boolean;
@@ -42,6 +43,7 @@ export function getAssertionExports(targetText?: string): {
     exportType: string;
     exportName: string;
     definitions: any;
+    keys: any;
     from: string;
     assertion: string;
     assertionType: string;

package/types/get-exports.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"get-exports.d.ts","sourceRoot":"","sources":["../src/get-exports.js"],"names":[],"mappings":"AAiBA,2DA+BC;AAED;;;;;;;;IAqDC;AAED;;;;;;IAeC;AAED,uEAuBC;AAED;;;;;;IAeC;AAED;;;;;;;IAgBC;AAED;;;;;;IAeC;AAED;;;;;;;;;;;;IA0BC"}

package/types/index.d.ts

@@ -1,4 +1,4 @@
-export function extractDeps(code: any): {
+export function extractDeps(code: any, filePath?: string): {
     imports: {
         line: string;
         varType: string;
@@ -9,6 +9,7 @@ export function extractDeps(code: any): {
         isImport: boolean;
         isRelative: boolean;
     }[];
+    exports: any[];
     requires: {
         line: string;
         varType: string;
@@ -20,8 +21,11 @@ export function extractDeps(code: any): {
         isRelative: boolean;
         isDynamic: boolean;
     }[];
-    exports: any[];
+    moduleExports: any[];
 };
+import { hasESMSyntax } from "./detect-syntax";
+import { hasCJSSyntax } from "./detect-syntax";
+import { detectSyntax } from "./detect-syntax";
 import { getRequires } from "./get-requires";
 import { getDynamicRequires } from "./get-requires";
 import { getStaticRequires } from "./get-requires";
@@ -35,5 +39,5 @@ 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 };
+export { hasESMSyntax, hasCJSSyntax, detectSyntax, getRequires, getDynamicRequires, getStaticRequires, getImports, getStaticImports, getDynamicImports, getExports, getDefaultExports, getNamedExports, getNamedDeclarationExports, getAllExports, getNamespaceExports, getTypeExports };
 //# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

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

package/types/utils.d.ts

@@ -1,4 +1,5 @@
 export function isRelativeImport(importLocation: any): boolean;
 export function isRelativeImportWithQuotes(importLocation: any): boolean;
-export function getNames(names: any): any;
+export function getNames(names: any, aliasKey?: string): any;
+export function extractExportName(exportValue: any): any;
 //# sourceMappingURL=utils.d.ts.map

package/types/utils.d.ts.map

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