@komaci/esm-generator 260.30.0 → 262.3.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__/index.spec.js

@@ -290,4 +290,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/index.js

@@ -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.30.0",
+    "version": "262.3.0",
     "description": "Komaci generator for ADG ES modules",
     "homepage": "https://komaci.dev/",
     "repository": {