@komaci/esm-generator 258.0.0 → 260.0.402

package/build/__tests__/adgAstGeneration.spec.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const common_shared_1 = require("@komaci/common-shared");
+const metadata_1 = require("@lwc/metadata");
 const functionAstGeneration_1 = require("../functionAstGeneration");
+const index_1 = require("../index");
 describe('getAdgFunctionBody', () => {
     const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
     it('includes a statement for factory functions if needed', () => {
@@ -219,4 +221,207 @@ describe('composeAdgStaticMetadata', () => {
         expect(properties[2].value.value).toBeFalsy();
     });
 });
+describe('Actual TypeScript File Processing', () => {
+    it('includes .ts files when reading bundles', () => {
+        const testFiles = [
+            'component.js',
+            'component.ts',
+            'component.html',
+            'component.css',
+            'other.txt',
+        ];
+        const LWC_EXT = ['.js', '.mjs', '.css', '.html', '.ts'];
+        const filtered = testFiles.filter((filename) => {
+            return LWC_EXT.some((ext) => filename.endsWith(ext));
+        });
+        expect(filtered).toContain('component.ts');
+        expect(filtered).not.toContain('other.txt');
+    });
+    // Test with actual TypeScript syntax
+    it('processes TypeScript files with type annotations', () => {
+        const typescriptSource = `
+import { LightningElement, api } from 'lwc';
+
+interface User {
+    id: string;
+    name: string;
+}
+
+export default class TypeScriptComponent extends LightningElement {
+    @api recordId: string;
+    private users: User[] = [];
+    
+    get userCount(): number {
+        return this.users.length;
+    }
+    
+    handleUserUpdate(user: User): void {
+        this.users = [...this.users, user];
+    }
+}`;
+        // Create a proper KomaciDocument structure
+        const komaciDoc = {
+            adgs: [{}],
+            exports: {
+                default: {
+                    type: 'AdgReference',
+                    value: 0,
+                },
+            },
+        };
+        expect(() => {
+            const input = {
+                moduleInfo: {
+                    name: 'typeScriptComponent',
+                    namespace: 'c',
+                    type: 'file',
+                    fileName: 'typeScriptComponent.ts',
+                    komaciDoc,
+                },
+                srcFileMap: {
+                    'typeScriptComponent.ts': typescriptSource,
+                },
+            };
+            (0, index_1.generateKomaciModule)(input);
+        }).not.toThrow();
+    });
+    // Test that ensures TypeScript-specific syntax is parsed correctly
+    it('handles TypeScript generics and interfaces', () => {
+        const typescriptGenericSource = `
+import { LightningElement } from 'lwc';
+
+interface ApiResponse<T> {
+    data: T;
+    success: boolean;
+}
+
+export default class GenericComponent<T = any> extends LightningElement {
+    private cache: Map<string, ApiResponse<T>> = new Map();
+    
+    get cacheSize(): number {
+        return this.cache.size;
+    }
+    
+    processResponse<U extends T>(response: ApiResponse<U>): U | null {
+        if (response.success) {
+            return response.data;
+        }
+        return null;
+    }
+}`;
+        // Create a proper KomaciDocument structure
+        const komaciDoc = {
+            adgs: [{}],
+            exports: {
+                default: {
+                    type: 'AdgReference',
+                    value: 0,
+                },
+            },
+        };
+        expect(() => {
+            const input = {
+                moduleInfo: {
+                    name: 'genericComponent',
+                    namespace: 'c',
+                    type: 'file',
+                    fileName: 'genericComponent.ts',
+                    komaciDoc,
+                },
+                srcFileMap: {
+                    'genericComponent.ts': typescriptGenericSource,
+                },
+            };
+            (0, index_1.generateKomaciModule)(input);
+        }).not.toThrow();
+    });
+    // Test bundle processing with .ts files
+    it('processes bundles containing TypeScript files', () => {
+        const bundleFiles = [
+            {
+                fileName: 'component.ts',
+                source: `
+import { LightningElement, api } from 'lwc';
+
+export default class Component extends LightningElement {
+    @api recordId: string;
+    
+    get displayName(): string {
+        return 'TypeScript Component';
+    }
+}`,
+            },
+            {
+                fileName: 'component.html',
+                source: '<template><div>{displayName}</div></template>',
+            },
+            {
+                fileName: 'component.css',
+                source: 'div { color: blue; }',
+            },
+        ];
+        // Test that bundles with .ts files are processed correctly
+        expect(() => {
+            const bundleConfig = {
+                namespace: 'c',
+                name: 'tsComponent',
+                type: 'internal',
+                namespaceMapping: {},
+                npmModuleMapping: {},
+                files: bundleFiles,
+                enableKomaci: true,
+            };
+            // This should work with .ts files
+            const metadata = (0, metadata_1.collectBundleMetadata)(bundleConfig);
+            expect(metadata.files.length).toBeGreaterThan(0);
+            const tsFile = metadata.files.find((f) => f.fileName === 'component.ts');
+            expect(tsFile).toBeDefined();
+        }).not.toThrow();
+    });
+    // Test that verifies the file extension is properly detected
+    it('detects TypeScript files by .ts extension', () => {
+        // Create a proper KomaciDocument structure
+        const komaciDoc = {
+            adgs: [{}],
+            exports: {
+                default: {
+                    type: 'AdgReference',
+                    value: 0,
+                },
+            },
+        };
+        const input = {
+            moduleInfo: {
+                name: 'test',
+                namespace: 'c',
+                type: 'file',
+                fileName: 'test.ts',
+                komaciDoc,
+            },
+            srcFileMap: {
+                'test.ts': 'export default class Component {}',
+            },
+        };
+        // Verify the filename extension is preserved and recognized
+        expect(input.moduleInfo.fileName).toContain('.ts');
+        // The module generation should handle .ts files
+        expect(() => (0, index_1.generateKomaciModule)(input)).not.toThrow();
+    });
+});
+describe('TypeScript Parser Configuration', () => {
+    it('includes TypeScript plugin in Babel parser configuration', () => {
+        // This test ensures that when we fix the parser, it includes TS support
+        const typescriptCode = `
+interface Props {
+    title: string;
+}
+
+export default class Component extends LightningElement {
+    @api title: string = '';
+}`;
+        expect(() => {
+            (0, common_shared_1.generateAstFromSrcCode)(typescriptCode);
+        }).not.toThrow();
+    });
+});
 //# sourceMappingURL=adgAstGeneration.spec.js.map

package/build/__tests__/readAndParseBundle.js

@@ -15,7 +15,7 @@ function readBundle(path) {
     path = (0, path_1.resolve)(path);
     if ((0, fs_1.existsSync)(path)) {
         const contents = (0, fs_1.readdirSync)(path);
-        const LWC_EXT = ['.js', '.mjs', '.css', '.html'];
+        const LWC_EXT = ['.js', '.mjs', '.css', '.html', '.ts'];
         const lwcBundleFiles = contents.filter((filename) => {
             return LWC_EXT.includes((0, path_1.extname)(filename));
         });

package/build/componentAstProcessing.js

@@ -15,7 +15,8 @@ function getComponentSrcJs(generatorInput) {
     let sourceCode;
     const moduleName = generatorInput.moduleInfo.name;
     if (generatorInput.srcFileMap) {
-        const filename = Object.keys(generatorInput.srcFileMap).find((filename) => filename.endsWith('.js') && filename.startsWith(moduleName));
+        const filename = Object.keys(generatorInput.srcFileMap).find((filename) => (filename.endsWith('.js') || filename.endsWith('.ts')) &&
+            filename.startsWith(moduleName));
         if (filename) {
             sourceCode = generatorInput.srcFileMap[filename];
         }

package/build/index.js

@@ -104,7 +104,7 @@ function processGeneratorInputAndState(input) {
             templateMap[input.moduleInfo.name] = input.moduleInfo.komaciDoc;
             sourceFile = (0, genericAstGeneration_1.generateResolvableModule)(input, undefined, templateMap, source);
         }
-        else if (fileExt === 'js') {
+        else if (fileExt === 'js' || fileExt === 'ts') {
             sourceFile = (0, genericAstGeneration_1.generateResolvableModule)(input, input.moduleInfo.komaciDoc, undefined, source);
         }
         else {

package/package.json

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