@komaci/esm-generator 260.31.0 → 262.9.0

package/build/__tests__/adgAstGeneration.spec.js

@@ -376,6 +376,26 @@ export default class Component extends LightningElement {
             expect(metadata.files.length).toBeGreaterThan(0);
             const tsFile = metadata.files.find((f) => f.fileName === 'component.ts');
             expect(tsFile).toBeDefined();
+            expect(tsFile?.komaciDoc).toBeDefined();
+            // Now verify the full ADG generation path works with TypeScript bundle
+            const srcFileMap = bundleFiles.reduce((map, { fileName, source }) => ({ ...map, [fileName]: source }), {});
+            const inputFiles = Object.fromEntries(metadata.files
+                .map(({ fileName, komaciDoc }) => [fileName, komaciDoc])
+                .filter(([, komaciDoc]) => !!komaciDoc));
+            const generatorInput = {
+                moduleInfo: {
+                    name: bundleConfig.name,
+                    namespace: bundleConfig.namespace,
+                    type: 'bundle',
+                    files: inputFiles,
+                },
+                srcFileMap,
+            };
+            // This exercises the full code path including the fix at line ~134
+            const result = (0, index_1.generateKomaciModule)(generatorInput);
+            // The result should be valid JavaScript and not an error
+            expect(result).not.toContain('ErrorFunction');
+            expect(result).not.toContain('unsupported file extension');
         }).not.toThrow();
     });
     // Test that verifies the file extension is properly detected

package/build/__tests__/functionAstGeneration.spec.js

@@ -568,26 +568,16 @@ describe('adgToExpression', () => {
 });
 describe('produceErrorAdgFunction', () => {
     it('should produce a resolvable module with an adg with only one node that shows what the error was', () => {
-        const expected = `import registerAdgFunction from "komaci/registerAdgFunction";
-
-function adg0(fct, ctx) {
-  const {
-    adg
-  } = fct;
-  return adg(undefined, {}, [{
-    t: "ErrorFunction",
-    c: {
-      "error": "something bad happened"
-    }
-  }], (fct, ctx) => {
-    return [];
-  }, []);
-}
-
-export default registerAdgFunction(adg0);`;
         const testError = new Error('something bad happened');
         const res = (0, functionAstGeneration_1.produceErrorAdgFunction)((0, common_shared_1.initModuleMetadataObject)(), testError);
-        expect((0, generator_1.default)((0, types_1.file)(res)).code).toBe(expected);
+        const generatedCode = (0, generator_1.default)((0, types_1.file)(res)).code;
+        // Verify the essential parts are present
+        expect(generatedCode).toContain('import registerAdgFunction from "komaci/registerAdgFunction"');
+        expect(generatedCode).toContain('function adg0(fct, ctx)');
+        expect(generatedCode).toContain('t: "ErrorFunction"');
+        expect(generatedCode).toContain('something bad happened');
+        expect(generatedCode).toContain('Extra Debug Info');
+        expect(generatedCode).toContain('export default registerAdgFunction(adg0)');
     });
 });
 describe('composeStaticMetadataAssignmentExpression', () => {

package/build/__tests__/index.spec.js

@@ -41,24 +41,12 @@ describe('Handling errors that throw inside a call to generateKomaciModule', ()
             },
         };
         const res = (0, __1.generateKomaciModule)(input);
-        const expectedModuleFirstHalf = 'import registerAdgFunction from "komaci/registerAdgFunction";\n\n' +
-            'function adg0(fct, ctx) {\n' +
-            '  const {\n' +
-            '    adg\n' +
-            '  } = fct;\n' +
-            '  return adg(undefined, {}, [{\n' +
-            '    t: "ErrorFunction",\n' +
-            '    c: {\n' +
-            '      "error": "[komaci esm-generator] unrecognized input type"\n';
-        const expectedModuleSecondHalf = '    return [];\n' +
-            '  }, []);\n' +
-            '}\n' +
-            '\nexport default registerAdgFunction(adg0);';
-        const lines = res.split('\n');
-        const skipStack = lines.slice(0, 10).join('\n') + '\n';
-        const skipStackEnd = lines.slice(lines.length - 5).join('\n');
-        expect(skipStack).toBe(expectedModuleFirstHalf);
-        expect(skipStackEnd).toBe(expectedModuleSecondHalf);
+        // Verify it contains ErrorFunction
+        expect(res).toContain('t: "ErrorFunction"');
+        expect(res).toContain('[komaci esm-generator] unrecognized input type');
+        expect(res).toContain('Extra Debug Info');
+        expect(res).toContain('Source Files:');
+        expect(res).toContain('registerAdgFunction(adg0)');
     });
     it('should return error adg when something not an error is thrown', () => {
         const input = {
@@ -79,24 +67,12 @@ describe('Handling errors that throw inside a call to generateKomaciModule', ()
             throw 'not an error';
         });
         const res = (0, __1.generateKomaciModule)(input);
-        const expectedModuleFirstHalf = 'import registerAdgFunction from "komaci/registerAdgFunction";\n\n' +
-            'function adg0(fct, ctx) {\n' +
-            '  const {\n' +
-            '    adg\n' +
-            '  } = fct;\n' +
-            '  return adg(undefined, {}, [{\n' +
-            '    t: "ErrorFunction",\n' +
-            '    c: {\n' +
-            '      "error": "[komaci] Something that is not an error was thrown"\n';
-        const expectedModuleSecondHalf = '    return [];\n' +
-            '  }, []);\n' +
-            '}\n' +
-            '\nexport default registerAdgFunction(adg0);';
-        const lines = res.split('\n');
-        const skipStack = lines.slice(0, 10).join('\n') + '\n';
-        const skipStackEnd = lines.slice(lines.length - 5).join('\n');
-        expect(skipStack).toBe(expectedModuleFirstHalf);
-        expect(skipStackEnd).toBe(expectedModuleSecondHalf);
+        // Verify it contains ErrorFunction with debug info
+        expect(res).toContain('t: "ErrorFunction"');
+        expect(res).toContain('[komaci] Something that is not an error was thrown');
+        expect(res).toContain('Extra Debug Info');
+        expect(res).toContain('Files in bundle:');
+        expect(res).toContain('registerAdgFunction(adg0)');
     });
     it('should return error adg when undefined is thrown', () => {
         const input = {
@@ -117,24 +93,12 @@ describe('Handling errors that throw inside a call to generateKomaciModule', ()
             throw undefined;
         });
         const res = (0, __1.generateKomaciModule)(input);
-        const expectedModuleFirstHalf = 'import registerAdgFunction from "komaci/registerAdgFunction";\n\n' +
-            'function adg0(fct, ctx) {\n' +
-            '  const {\n' +
-            '    adg\n' +
-            '  } = fct;\n' +
-            '  return adg(undefined, {}, [{\n' +
-            '    t: "ErrorFunction",\n' +
-            '    c: {\n' +
-            '      "error": "[komaci] Something that is not an error was thrown"\n';
-        const expectedModuleSecondHalf = '    return [];\n' +
-            '  }, []);\n' +
-            '}\n' +
-            '\nexport default registerAdgFunction(adg0);';
-        const lines = res.split('\n');
-        const skipStack = lines.slice(0, 10).join('\n') + '\n';
-        const skipStackEnd = lines.slice(lines.length - 5).join('\n');
-        expect(skipStack).toBe(expectedModuleFirstHalf);
-        expect(skipStackEnd).toBe(expectedModuleSecondHalf);
+        // Verify it contains ErrorFunction
+        expect(res).toContain('t: "ErrorFunction"');
+        expect(res).toContain('[komaci] Something that is not an error was thrown');
+        expect(res).toContain('Extra Debug Info');
+        expect(res).toContain('Files in bundle:');
+        expect(res).toContain('registerAdgFunction(adg0)');
     });
 });
 describe('normalizeSrcFileKeys', () => {
@@ -290,4 +254,212 @@ describe('normalizeSrcFileKeys', () => {
         expect(input.srcFileMap['templates/test2.html']).not.toBeUndefined();
     });
 });
+describe('TypeScript Bundle Processing', () => {
+    it('should process bundles containing TypeScript files', () => {
+        // Create a proper KomaciDocument structure for TypeScript file
+        const komaciDoc = {
+            adgs: [{}],
+            exports: {
+                default: {
+                    type: 'AdgReference',
+                    value: 0,
+                },
+            },
+        };
+        const input = {
+            moduleInfo: {
+                name: 'tsComponent',
+                namespace: 'c',
+                type: 'bundle',
+                files: {
+                    'tsComponent.ts': komaciDoc,
+                    'tsComponent.html': {},
+                },
+            },
+            srcFileMap: {
+                'tsComponent.ts': `
+import { LightningElement, api } from 'lwc';
+
+export default class TsComponent extends LightningElement {
+    @api recordId: string;
+    
+    get displayName(): string {
+        return 'TypeScript Component';
+    }
+}`,
+                'tsComponent.html': '<template><div>{displayName}</div></template>',
+            },
+        };
+        // This should NOT throw an error
+        expect(() => {
+            const result = (0, __1.generateKomaciModule)(input);
+            expect(result).toContain('registerAdgFunction');
+            expect(result).not.toContain('ErrorFunction');
+        }).not.toThrow();
+    });
+    it('should handle bundle with only TypeScript file (no HTML)', () => {
+        const komaciDoc = {
+            adgs: [{}],
+            exports: {
+                default: {
+                    type: 'AdgReference',
+                    value: 0,
+                },
+            },
+        };
+        const input = {
+            moduleInfo: {
+                name: 'tsOnly',
+                namespace: 'c',
+                type: 'bundle',
+                files: {
+                    'tsOnly.ts': komaciDoc,
+                },
+            },
+            srcFileMap: {
+                'tsOnly.ts': `
+import { LightningElement } from 'lwc';
+
+export default class TsOnly extends LightningElement {
+    message: string = 'Hello TypeScript';
+}`,
+            },
+        };
+        expect(() => {
+            const result = (0, __1.generateKomaciModule)(input);
+            expect(result).toContain('registerAdgFunction');
+        }).not.toThrow();
+    });
+    it('should handle TypeScript with complex type annotations', () => {
+        const komaciDoc = {
+            adgs: [{}],
+            exports: {
+                default: {
+                    type: 'AdgReference',
+                    value: 0,
+                },
+            },
+        };
+        const input = {
+            moduleInfo: {
+                name: 'complexTs',
+                namespace: 'c',
+                type: 'bundle',
+                files: {
+                    'complexTs.ts': komaciDoc,
+                },
+            },
+            srcFileMap: {
+                'complexTs.ts': `
+import { LightningElement, api } from 'lwc';
+
+interface User {
+    id: string;
+    name: string;
+}
+
+export default class ComplexTs extends LightningElement {
+    @api recordId: string;
+    private users: User[] = [];
+    
+    get userCount(): number {
+        return this.users.length;
+    }
+}`,
+            },
+        };
+        expect(() => {
+            const result = (0, __1.generateKomaciModule)(input);
+            expect(result).toContain('registerAdgFunction');
+        }).not.toThrow();
+    });
+    it('should handle mixed bundle with both .js and .ts files', () => {
+        const jsDoc = {
+            adgs: [{}],
+            exports: {
+                default: {
+                    type: 'AdgReference',
+                    value: 0,
+                },
+            },
+        };
+        const tsDoc = {
+            adgs: [{}],
+            exports: {
+                helper: {
+                    type: 'AdgReference',
+                    value: 0,
+                },
+            },
+        };
+        const input = {
+            moduleInfo: {
+                name: 'mixedComponent',
+                namespace: 'c',
+                type: 'bundle',
+                files: {
+                    'mixedComponent.js': jsDoc,
+                    'helper.ts': tsDoc,
+                    'mixedComponent.html': {},
+                },
+            },
+            srcFileMap: {
+                'mixedComponent.js': `
+import { LightningElement } from 'lwc';
+export default class MixedComponent extends LightningElement {}`,
+                'helper.ts': `
+export function helperFunction(data: string): string {
+    return data.toUpperCase();
+}`,
+                'mixedComponent.html': '<template><div>Mixed</div></template>',
+            },
+        };
+        expect(() => {
+            const result = (0, __1.generateKomaciModule)(input);
+            expect(result).toContain('registerAdgFunction');
+        }).not.toThrow();
+    });
+    it('should throw error with unsupported file extension in bundle', () => {
+        const input = {
+            moduleInfo: {
+                name: 'badComponent',
+                namespace: 'c',
+                type: 'bundle',
+                files: {
+                    'badComponent.xyz': {},
+                },
+            },
+            srcFileMap: {
+                'badComponent.xyz': 'some content',
+            },
+        };
+        const result = (0, __1.generateKomaciModule)(input);
+        // Should generate an error ADG
+        expect(result).toContain('ErrorFunction');
+        expect(result).toContain('unsupported file extension: xyz');
+    });
+    it('should normalize TypeScript file paths in bundles', () => {
+        const bundleSrcFileMap = {
+            'c/tsComponent/tsComponent.ts': {},
+            'c/tsComponent/tsComponent.html': {},
+        };
+        const input = {
+            moduleInfo: {
+                name: 'tsComponent',
+                namespace: 'c',
+                type: 'bundle',
+                files: bundleSrcFileMap,
+            },
+            srcFileMap: {
+                'c/tsComponent/tsComponent.ts': 'export default class TsComponent {}',
+                'c/tsComponent/tsComponent.html': '<template><div>TS</div></template>',
+            },
+        };
+        (0, __1.normalizeSrcFileKeys)(input);
+        expect(input.moduleInfo.files['tsComponent.ts']).not.toBeUndefined();
+        expect(input.moduleInfo.files['tsComponent.html']).not.toBeUndefined();
+        expect(input.srcFileMap['tsComponent.ts']).not.toBeUndefined();
+        expect(input.srcFileMap['tsComponent.html']).not.toBeUndefined();
+    });
+});
 //# sourceMappingURL=index.spec.js.map

package/build/__tests__/produceErrorAdgFunction-debug.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=produceErrorAdgFunction-debug.spec.d.ts.map

package/build/__tests__/produceErrorAdgFunction-debug.spec.js

@@ -0,0 +1,387 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const functionAstGeneration_1 = require("../functionAstGeneration");
+const common_shared_1 = require("@komaci/common-shared");
+const generator_1 = __importDefault(require("@babel/generator"));
+const types_1 = require("@babel/types");
+describe('produceErrorAdgFunction with debug information', () => {
+    describe('with bundle module input', () => {
+        it('should include module name, namespace, and file information in error message', () => {
+            const komaciJsDoc = {
+                adgs: [
+                    {
+                        properties: {
+                            recordId: { isPublic: true },
+                            record: { isPublic: false },
+                        },
+                        functions: [],
+                    },
+                ],
+                imports: [
+                    { resourceName: 'lwc', names: ['LightningElement'] },
+                    { resourceName: 'lightning/uiRecordApi', names: ['getRecord'] },
+                ],
+                exports: {
+                    default: { type: 'AdgReference', value: 0 },
+                },
+            };
+            const komaciHtmlDoc = {
+                compositions: [
+                    { type: 'Container' },
+                    { type: 'Slot', name: 'default' },
+                ],
+            };
+            const input = {
+                moduleInfo: {
+                    name: 'myTestComponent',
+                    namespace: 'c',
+                    type: 'bundle',
+                    files: {
+                        'myTestComponent.js': komaciJsDoc,
+                        'myTestComponent.html': komaciHtmlDoc,
+                    },
+                },
+                srcFileMap: {
+                    'myTestComponent.js': 'export default class MyTestComponent extends LightningElement {\n  @api recordId;\n}',
+                    'myTestComponent.html': '<template>\n  <div>Test</div>\n</template>',
+                    'myTestComponent.css': '.test { color: red; }',
+                },
+            };
+            const testError = new Error('Unexpected token (34:14)');
+            testError.stack =
+                'Error: Unexpected token (34:14)\n    at Parser._raise (/path/parser.js:762:17)\n    at generateAstFromSrcCode (/path/parser.ts:11:23)';
+            const result = (0, functionAstGeneration_1.produceErrorAdgFunction)((0, common_shared_1.initModuleMetadataObject)(), testError, input);
+            const generatedCode = (0, generator_1.default)((0, types_1.file)(result)).code;
+            // Verify error message is present
+            expect(generatedCode).toContain('Unexpected token (34:14)');
+            // Verify stack trace is present
+            expect(generatedCode).toContain('Parser._raise');
+            expect(generatedCode).toContain('generateAstFromSrcCode');
+            // Verify debug info section exists
+            expect(generatedCode).toContain('Extra Debug Info:');
+            // Verify file list
+            expect(generatedCode).toContain('Files in bundle:');
+            expect(generatedCode).toContain('myTestComponent.js');
+            expect(generatedCode).toContain('myTestComponent.html');
+            // Verify KomaciDoc structure info for JS file
+            expect(generatedCode).toContain('File: myTestComponent.js');
+            expect(generatedCode).toContain('Has adgs: yes (1)');
+            expect(generatedCode).toContain('Has imports: yes (2)');
+            expect(generatedCode).toContain('Has exports: yes');
+            // Verify KomaciDoc structure info for HTML file
+            expect(generatedCode).toContain('File: myTestComponent.html');
+            expect(generatedCode).toContain('Has compositions: yes (2)');
+            // Verify source file information
+            expect(generatedCode).toContain('Source Files:');
+            expect(generatedCode).toContain('myTestComponent.js:');
+            expect(generatedCode).toContain('chars');
+            expect(generatedCode).toContain('lines');
+        });
+        it('should handle bundle with no KomaciDoc gracefully', () => {
+            const input = {
+                moduleInfo: {
+                    name: 'emptyComponent',
+                    namespace: 'lightning',
+                    type: 'bundle',
+                    files: {
+                        'emptyComponent.js': {},
+                    },
+                },
+                srcFileMap: {
+                    'emptyComponent.js': '',
+                },
+            };
+            const testError = new Error('No adgs found');
+            const result = (0, functionAstGeneration_1.produceErrorAdgFunction)((0, common_shared_1.initModuleMetadataObject)(), testError, input);
+            const generatedCode = (0, generator_1.default)((0, types_1.file)(result)).code;
+            expect(generatedCode).toContain('emptyComponent.js');
+            expect(generatedCode).toContain('Has adgs: no');
+            expect(generatedCode).toContain('Has imports: no');
+            expect(generatedCode).toContain('Has exports: no');
+        });
+        it('should include all source files with correct statistics', () => {
+            const input = {
+                moduleInfo: {
+                    name: 'multiFileComponent',
+                    namespace: 'c',
+                    type: 'bundle',
+                    files: {
+                        'multiFileComponent.js': {
+                            adgs: [{}],
+                            exports: { default: { type: 'AdgReference', value: 0 } },
+                        },
+                    },
+                },
+                srcFileMap: {
+                    'multiFileComponent.js': 'line1\nline2\nline3\nline4\nline5',
+                    'multiFileComponent.html': '<template>\n  <div></div>\n</template>',
+                    'multiFileComponent.css': '.class { }',
+                    'helper.js': 'export const helper = () => {\n  return true;\n}', // 3 lines
+                },
+            };
+            const testError = new Error('Test error');
+            const result = (0, functionAstGeneration_1.produceErrorAdgFunction)((0, common_shared_1.initModuleMetadataObject)(), testError, input);
+            const generatedCode = (0, generator_1.default)((0, types_1.file)(result)).code;
+            // Verify all files are listed
+            expect(generatedCode).toContain('multiFileComponent.js:');
+            expect(generatedCode).toContain('multiFileComponent.html:');
+            expect(generatedCode).toContain('multiFileComponent.css:');
+            expect(generatedCode).toContain('helper.js:');
+            // Verify line counts
+            expect(generatedCode).toContain('5 lines');
+            expect(generatedCode).toContain('3 lines');
+            expect(generatedCode).toContain('1 lines');
+        });
+    });
+    describe('with file module input', () => {
+        it('should include file-specific information for single file modules', () => {
+            const komaciDoc = {
+                adgs: [
+                    {
+                        properties: {
+                            value: { isPublic: true },
+                        },
+                    },
+                ],
+                imports: [{ resourceName: 'lwc', names: ['api'] }],
+                exports: {
+                    default: { type: 'AdgReference', value: 0 },
+                },
+            };
+            const input = {
+                moduleInfo: {
+                    name: 'singleFile',
+                    namespace: 'c',
+                    type: 'file',
+                    fileName: 'singleFile.js',
+                    komaciDoc,
+                },
+                srcFileMap: {
+                    'singleFile.js': 'export default class SingleFile {\n  @api value;\n}',
+                },
+            };
+            const testError = new Error('Parse error at line 42');
+            testError.stack =
+                'Error: Parse error at line 42\n    at parse (/path/to/parser.js:100:5)';
+            const result = (0, functionAstGeneration_1.produceErrorAdgFunction)((0, common_shared_1.initModuleMetadataObject)(), testError, input);
+            const generatedCode = (0, generator_1.default)((0, types_1.file)(result)).code;
+            // Verify error details
+            expect(generatedCode).toContain('Parse error at line 42');
+            expect(generatedCode).toContain('at parse');
+            // Verify debug info and file info
+            expect(generatedCode).toContain('Extra Debug Info:');
+            expect(generatedCode).toContain('File: singleFile.js');
+            // Verify KomaciDoc structure
+            expect(generatedCode).toContain('Has adgs: yes (1)');
+            expect(generatedCode).toContain('Has imports: yes (1)');
+            expect(generatedCode).toContain('Has exports: yes');
+            // Verify source info
+            expect(generatedCode).toContain('Source Files:');
+            expect(generatedCode).toContain('singleFile.js:');
+        });
+        it('should handle file module with empty KomaciDoc', () => {
+            const input = {
+                moduleInfo: {
+                    name: 'emptyFile',
+                    namespace: 'c',
+                    type: 'file',
+                    fileName: 'emptyFile.html',
+                    komaciDoc: {},
+                },
+            };
+            const testError = new Error('Empty document');
+            const result = (0, functionAstGeneration_1.produceErrorAdgFunction)((0, common_shared_1.initModuleMetadataObject)(), testError, input);
+            const generatedCode = (0, generator_1.default)((0, types_1.file)(result)).code;
+            expect(generatedCode).toContain('emptyFile.html');
+            expect(generatedCode).toContain('Has adgs: no');
+            expect(generatedCode).toContain('Has imports: no');
+            expect(generatedCode).toContain('Has exports: no');
+        });
+    });
+    describe('edge cases', () => {
+        it('should work without GeneratorInput (backward compatibility)', () => {
+            const testError = new Error('Simple error');
+            testError.stack = 'Error: Simple error\n    at test.js:1:1';
+            const result = (0, functionAstGeneration_1.produceErrorAdgFunction)((0, common_shared_1.initModuleMetadataObject)(), testError, undefined);
+            const generatedCode = (0, generator_1.default)((0, types_1.file)(result)).code;
+            // Should still have error and stack
+            expect(generatedCode).toContain('Simple error');
+            expect(generatedCode).toContain('test.js:1:1');
+            // But no debug info
+            expect(generatedCode).not.toContain('Files in bundle');
+            expect(generatedCode).not.toContain('Source Files');
+        });
+        it('should handle error without stack trace', () => {
+            const testError = new Error('Error with no stack');
+            testError.stack = undefined;
+            const input = {
+                moduleInfo: {
+                    name: 'test',
+                    namespace: 'c',
+                    type: 'file',
+                    fileName: 'test.js',
+                    komaciDoc: {},
+                },
+            };
+            const result = (0, functionAstGeneration_1.produceErrorAdgFunction)((0, common_shared_1.initModuleMetadataObject)(), testError, input);
+            const generatedCode = (0, generator_1.default)((0, types_1.file)(result)).code;
+            expect(generatedCode).toContain('Error with no stack');
+            expect(generatedCode).toContain('Extra Debug Info:');
+            expect(generatedCode).toContain('File: test.js');
+            // Stack should be undefined, not the string "stack"
+            expect(generatedCode).toContain('"stack": undefined');
+        });
+        it('should handle srcFileMap with empty files', () => {
+            const input = {
+                moduleInfo: {
+                    name: 'emptySource',
+                    namespace: 'c',
+                    type: 'bundle',
+                    files: {
+                        'emptySource.js': {},
+                    },
+                },
+                srcFileMap: {
+                    'emptySource.js': '',
+                    'emptySource.html': '', // Empty source
+                },
+            };
+            const testError = new Error('Empty files');
+            const result = (0, functionAstGeneration_1.produceErrorAdgFunction)((0, common_shared_1.initModuleMetadataObject)(), testError, input);
+            const generatedCode = (0, generator_1.default)((0, types_1.file)(result)).code;
+            expect(generatedCode).toContain('emptySource.js: 0 chars, 1 lines');
+            expect(generatedCode).toContain('emptySource.html: 0 chars, 1 lines');
+        });
+        it('should handle module with many imports and functions', () => {
+            const complexKomaciDoc = {
+                adgs: [
+                    {
+                        properties: {
+                            prop1: { isPublic: true },
+                            prop2: { isPublic: true },
+                            prop3: { isPublic: false },
+                        },
+                        functions: [
+                            {
+                                type: 'WireFunction',
+                                reference: {
+                                    type: 'ImportReference',
+                                    value: '0/names/0',
+                                },
+                            },
+                            {
+                                type: 'WireFunction',
+                                reference: {
+                                    type: 'ImportReference',
+                                    value: '1/names/0',
+                                },
+                            },
+                            {
+                                type: 'WireFunction',
+                                reference: {
+                                    type: 'ImportReference',
+                                    value: '2/names/0',
+                                },
+                            },
+                        ],
+                    },
+                ],
+                imports: [
+                    { resourceName: 'lightning/uiRecordApi', names: ['getRecord'] },
+                    { resourceName: 'lightning/uiRecordApi', names: ['getRecordUi'] },
+                    {
+                        resourceName: '@salesforce/apex/MyController.getData',
+                        names: ['default'],
+                    },
+                    { resourceName: '@salesforce/user/Id', names: ['default'] },
+                    { resourceName: 'c/childComponent', names: ['default'] },
+                ],
+                compositions: [
+                    { type: 'Container' },
+                    { type: 'Slot', name: 'default' },
+                    {
+                        type: 'ComposedAdg',
+                        input: { type: 'ImportReference', value: '4/names/0' },
+                    },
+                ],
+                exports: {
+                    default: { type: 'AdgReference', value: 0 },
+                },
+            };
+            const input = {
+                moduleInfo: {
+                    name: 'complexComponent',
+                    namespace: 'c',
+                    type: 'file',
+                    fileName: 'complexComponent.js',
+                    komaciDoc: complexKomaciDoc,
+                },
+            };
+            const testError = new Error('Complex component error');
+            const result = (0, functionAstGeneration_1.produceErrorAdgFunction)((0, common_shared_1.initModuleMetadataObject)(), testError, input);
+            const generatedCode = (0, generator_1.default)((0, types_1.file)(result)).code;
+            expect(generatedCode).toContain('Has adgs: yes (1)');
+            expect(generatedCode).toContain('Has imports: yes (5)');
+            expect(generatedCode).toContain('Has exports: yes');
+            // Note: file type modules don't show compositions in the debug output
+            // since compositions are part of the KomaciDoc structure
+        });
+    });
+    describe('real-world error scenarios', () => {
+        it('should provide useful debug info for Babel parse errors', () => {
+            const input = {
+                moduleInfo: {
+                    name: 'syntaxError',
+                    namespace: 'c',
+                    type: 'bundle',
+                    files: {
+                        'syntaxError.js': {
+                            adgs: [
+                                {
+                                    properties: {
+                                        value: { isPublic: true },
+                                    },
+                                },
+                            ],
+                            exports: { default: { type: 'AdgReference', value: 0 } },
+                        },
+                    },
+                },
+                srcFileMap: {
+                    'syntaxError.js': `import { LightningElement } from 'lwc';
+export default class SyntaxError extends LightningElement {
+    get computedValue() {
+        return this?.value ?? 'default';  // Line 4
+    }
+}`,
+                },
+            };
+            const babelError = new Error('Unexpected token (4:21)');
+            babelError.stack = `Error: Unexpected token (4:21)
+    at Parser._raise (/node_modules/@babel/parser/lib/index.js:762:17)
+    at Parser.raiseWithData (/node_modules/@babel/parser/lib/index.js:755:17)
+    at Parser.raise (/node_modules/@babel/parser/lib/index.js:749:17)
+    at generateAstFromSrcCode (packages/@komaci/common-shared/src/parser.ts:11:23)
+    at generateResolvableModule (packages/@komaci/esm-generator/src/genericAstGeneration.ts:146:19)`;
+            const result = (0, functionAstGeneration_1.produceErrorAdgFunction)((0, common_shared_1.initModuleMetadataObject)(), babelError, input);
+            const generatedCode = (0, generator_1.default)((0, types_1.file)(result)).code;
+            // Developer can now see:
+            // 1. Debug info section
+            expect(generatedCode).toContain('Extra Debug Info:');
+            // 2. The exact error
+            expect(generatedCode).toContain('Unexpected token (4:21)');
+            // 3. Where it failed in the stack
+            expect(generatedCode).toContain('Parser._raise');
+            expect(generatedCode).toContain('generateAstFromSrcCode');
+            // 4. What the source looks like
+            expect(generatedCode).toContain('syntaxError.js:');
+            expect(generatedCode).toContain('6 lines');
+            // 5. What was in the KomaciDoc
+            expect(generatedCode).toContain('Has adgs: yes (1)');
+        });
+    });
+});
+//# sourceMappingURL=produceErrorAdgFunction-debug.spec.js.map

package/build/functionAstGeneration.d.ts

@@ -2,6 +2,7 @@ import { NodePath } from '@babel/core';
 import * as t from '@babel/types';
 import { AdgMetadata, HoistedFunctionMetadata, IdKeys, ImportMetadata, ModuleMetadata, GqlMetadata } from '@komaci/common-shared';
 import { Composition } from '@komaci/types';
+import { GeneratorInput } from './types';
 /**
  * Take a local function (getter, template string, etc) and prepare it for the resolvable module
  * - sanitize the function
@@ -84,7 +85,7 @@ export declare function getInlineFunctionFromTemplateCompositions(moduleMetadata
  * @param error The error that was thrown
  * @returns A default export representing the error state for this resolvable module
  */
-export declare function produceErrorAdgFunction(moduleMetadata: ModuleMetadata, error: Error): t.Program;
+export declare function produceErrorAdgFunction(moduleMetadata: ModuleMetadata, error: Error, generatorInput?: GeneratorInput | undefined): t.Program;
 /**
  * Helper function to return the static metadata assignemnt expression statement.
  * @param adgName the name of the adg function to associate the adgMeta object with.

package/build/functionAstGeneration.js

@@ -490,13 +490,54 @@ exports.getInlineFunctionFromTemplateCompositions = getInlineFunctionFromTemplat
  * @param error The error that was thrown
  * @returns A default export representing the error state for this resolvable module
  */
-function produceErrorAdgFunction(moduleMetadata, error) {
+function produceErrorAdgFunction(moduleMetadata, error, generatorInput = undefined) {
+    let extraDebugInfo = '';
+    if (generatorInput) {
+        // Log KomaciDocument structure
+        if (generatorInput.moduleInfo.type === 'bundle') {
+            const files = generatorInput.moduleInfo.files;
+            extraDebugInfo += `Files in bundle: ${Object.keys(files).join(', ')}\n`;
+            Object.entries(files).forEach(([fileName, komaciDoc]) => {
+                extraDebugInfo += `\n  File: ${fileName}:\n`;
+                extraDebugInfo += `    - Has adgs: ${komaciDoc?.adgs ? `yes (${komaciDoc.adgs.length})` : 'no'}\n`;
+                extraDebugInfo += `    - Has imports: ${komaciDoc?.imports ? `yes (${komaciDoc.imports.length})` : 'no'}\n`;
+                extraDebugInfo += `    - Has exports: ${komaciDoc?.exports ? 'yes' : 'no'}\n`;
+                extraDebugInfo += `    - Has compositions: ${komaciDoc?.compositions
+                    ? `yes (${komaciDoc.compositions.length})`
+                    : 'no'}\n`;
+            });
+        }
+        else {
+            const fileInfo = generatorInput.moduleInfo;
+            extraDebugInfo += `File: ${fileInfo.fileName}\n`;
+            extraDebugInfo += `  - Has adgs: ${fileInfo.komaciDoc?.adgs
+                ? `yes (${fileInfo.komaciDoc.adgs.length})`
+                : 'no'}\n`;
+            extraDebugInfo += `  - Has imports: ${fileInfo.komaciDoc?.imports
+                ? `yes (${fileInfo.komaciDoc.imports.length})`
+                : 'no'}\n`;
+            extraDebugInfo += `  - Has exports: ${fileInfo.komaciDoc?.exports ? 'yes' : 'no'}\n`;
+        }
+        // Log source files
+        if (generatorInput.srcFileMap) {
+            extraDebugInfo += '\n  Source Files:\n';
+            Object.entries(generatorInput.srcFileMap).forEach(([fileName, source]) => {
+                extraDebugInfo += `  - ${fileName}: ${source.length} chars, ${source.split('\n').length} lines\n`;
+            });
+        }
+    }
     const functionValues = {
         error: {
             type: 'PrimitiveValue',
             value: error instanceof Error
-                ? error.message
-                : common_shared_1.ERROR_PREFIX + 'Something that is not an error was thrown',
+                ? error.message + `\n\nExtra Debug Info:\n\n${extraDebugInfo}`
+                : common_shared_1.ERROR_PREFIX +
+                    'Something that is not an error was thrown' +
+                    `\n\nExtra Debug Info:\n\n${extraDebugInfo}`,
+        },
+        stack: {
+            type: 'PrimitiveValue',
+            value: error instanceof Error ? error.stack : 'No stack trace available',
         },
     };
     const registerAdgImport = t.importDeclaration([t.importDefaultSpecifier(t.identifier('registerAdgFunction'))], t.stringLiteral('komaci/registerAdgFunction'));

package/build/index.js

@@ -42,7 +42,7 @@ function generateKomaciModule(input) {
     }
     catch (e) {
         const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
-        const babelOutput = (0, generator_1.default)(t.file((0, functionAstGeneration_1.produceErrorAdgFunction)(moduleMetadata, e)));
+        const babelOutput = (0, generator_1.default)(t.file((0, functionAstGeneration_1.produceErrorAdgFunction)(moduleMetadata, e, input)));
         return babelOutput.code;
     }
 }
@@ -134,7 +134,7 @@ function processGeneratorInputAndState(input) {
             if (fileExt == 'html') {
                 filesMap['html'] = filesObj;
             }
-            else if (fileExt === 'js') {
+            else if (fileExt === 'js' || fileExt === 'ts') {
                 filesMap['js'] = filesObj;
             }
             else {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@komaci/esm-generator",
-    "version": "260.31.0",
+    "version": "262.9.0",
     "description": "Komaci generator for ADG ES modules",
     "homepage": "https://komaci.dev/",
     "repository": {