@komaci/esm-generator 264.5.0 → 266.3.0

package/build/genericAstGeneration.js

@@ -123,7 +123,7 @@ function generateResolvableModule(input, scriptKomaciDoc, templateKomaciDocMap,
     }
     // for script only docs we assume there there is still a html file around so we build the import to reference that html
     if (!isBundle && hasScriptKomaciDoc && !hasTemplateKomaciDoc) {
-        const newImport = (0, common_shared_1.composeImportMetadata)('default', `@salesforce/komaci/${input.moduleInfo.namespace}__${input.moduleInfo.name}__${input.moduleInfo.name}.html`, true, common_shared_1.NO_KOMACI_DOC_REF, moduleMetadata, common_shared_1.IdKeys.DEFAULT_COMP);
+        const newImport = (0, common_shared_1.composeImportMetadata)('default', `@salesforce/komaci/${input.moduleInfo.namespace}__${input.moduleInfo.name}__${input.moduleInfo.name}.html`, true, common_shared_1.NO_KOMACI_DOC_REF, moduleMetadata, common_shared_1.IdKeys.DEFAULT_COMP, false);
         newImport.usedInPriming = true;
         newImport.isFromSupportedLibrary = true;
         newImport.generatorAlias = 'comp1';
@@ -215,6 +215,27 @@ function generateResolvableModule(input, scriptKomaciDoc, templateKomaciDocMap,
     return file;
 }
 exports.generateResolvableModule = generateResolvableModule;
+/**
+ * Builds a single import declaration. If every specifier is type-only the declaration
+ * uses the decl-level `import type` form; if only some are type-only, the inline
+ * `type` modifier is applied per ImportSpecifier.
+ */
+function buildImportDeclaration(entries, resourceName) {
+    const specifiers = entries.map((e) => e.specifier);
+    const importDeclaration = t.importDeclaration(specifiers, t.stringLiteral(resourceName));
+    const allTypeOnly = entries.length > 0 && entries.every((e) => e.isTypeOnly);
+    if (allTypeOnly) {
+        importDeclaration.importKind = 'type';
+    }
+    else {
+        entries.forEach((entry) => {
+            if (entry.isTypeOnly && entry.specifier.type === 'ImportSpecifier') {
+                entry.specifier.importKind = 'type';
+            }
+        });
+    }
+    return importDeclaration;
+}
 /**
  * Adds a babel import decleration to the AST for each Komaci import
  *
@@ -228,6 +249,7 @@ exports.generateResolvableModule = generateResolvableModule;
 function addImportStatements(moduleMetadata, statements, options) {
     if (moduleMetadata.importsByName.size > 0) {
         const seenImports = new Set();
+        // Sort by resourceName for deterministic output order in the generated ADG.
         const imports = Array.from(moduleMetadata.importsByName.values())
             .sort((a, b) => {
             if (a.resourceName < b.resourceName) {
@@ -242,52 +264,76 @@ function addImportStatements(moduleMetadata, statements, options) {
         })
             .filter((value) => {
             // sometimes we can have multiple import names mapped to the same import. so we want to dedup those before running them through composition
+            // always include type imports
             const isComposable = !seenImports.has(value.generatorAlias) &&
                 value.isFromInternalNamespace &&
-                value.usedInPriming;
+                (value.usedInPriming || value.isTypeOnly);
             if (isComposable) {
                 seenImports.add(value.generatorAlias);
             }
             return isComposable;
         });
-        let i = 0;
-        while (i < imports.length) {
-            const specifiers = [];
-            let resourceName = imports[i].resourceName;
-            while (i < imports.length && imports[i].resourceName === resourceName) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const localName = t.identifier(imports[i].generatorAlias);
-                let specifier;
-                const exportName = imports[i].name;
+        // We can't use the standard groupBy helper until we update ES version target.
+        const importsByResource = new Map();
+        for (const imp of imports) {
+            const group = importsByResource.get(imp.resourceName) ?? [];
+            group.push(imp);
+            importsByResource.set(imp.resourceName, group);
+        }
+        for (const [originalResourceName, group] of importsByResource) {
+            if (!(0, static_analyzer_1.isSupportedNamespace)(originalResourceName)) {
+                continue;
+            }
+            // Partition all specifiers for this resource into the three ES grammar
+            // buckets so we can emit only the legal combined forms below.
+            //
+            // The metadata layer (collectImportMetadataFromAst + findOtherAlias) collapses
+            // multiple aliases of the same exported binding to a single ImportMetadata,
+            // and the dedup pass above strips duplicates by `generatorAlias`, so we are
+            // guaranteed at most one default and at most one namespace per resource here.
+            let defaultSpecifier;
+            let namespaceSpecifier;
+            const namedSpecifiers = [];
+            for (const imp of group) {
+                const localName = t.identifier(imp.generatorAlias);
+                const exportName = imp.name;
                 if (exportName === 'default') {
-                    // e.g. `import i1 from "@salesforce/user/Id";`
-                    specifier = t.importDefaultSpecifier(localName);
-                    specifiers.unshift(specifier);
+                    defaultSpecifier = {
+                        specifier: t.importDefaultSpecifier(localName),
+                        isTypeOnly: imp.isTypeOnly,
+                    };
                 }
-                else if (exportName === '*' &&
-                    moduleMetadata.importsByNamespace.get(resourceName)?.names.size === 1) {
-                    // e.g. `import i1 from "@salesforce/user/Id";`
-                    specifier = t.importNamespaceSpecifier(localName);
-                    specifiers.push(specifier);
+                else if (exportName === '*') {
+                    namespaceSpecifier = {
+                        specifier: t.importNamespaceSpecifier(localName),
+                        isTypeOnly: imp.isTypeOnly,
+                    };
                 }
                 else {
-                    // e.g. `import { getRecord as i1 } from "lightning/uiRecordApi";`.
-                    // `getRecord` is the exportName, `i1` is the localName
-                    specifier = t.importSpecifier(localName, t.identifier(exportName));
-                    specifiers.push(specifier);
+                    namedSpecifiers.push({
+                        specifier: t.importSpecifier(localName, t.identifier(exportName)),
+                        isTypeOnly: imp.isTypeOnly,
+                    });
                 }
-                i++;
             }
-            if ((0, static_analyzer_1.isSupportedNamespace)(resourceName) && specifiers.length > 0) {
-                if (options.isComposingFromBundle &&
-                    resourceName.startsWith('@salesforce/komaci')) {
-                    // @salesforce/komaci/c__foo__foo.js -> @salesforce/komaci/c__foo
-                    const lastIndex = resourceName.lastIndexOf('__');
-                    resourceName = resourceName.slice(0, lastIndex);
-                }
-                const resource = t.stringLiteral(resourceName);
-                const importDeclaration = t.importDeclaration(specifiers, resource);
-                statements.push(importDeclaration);
+            let resourceName = originalResourceName;
+            if (options.isComposingFromBundle &&
+                resourceName.startsWith('@salesforce/komaci')) {
+                // @salesforce/komaci/c__foo__foo.js -> @salesforce/komaci/c__foo
+                const lastIndex = resourceName.lastIndexOf('__');
+                resourceName = resourceName.slice(0, lastIndex);
+            }
+            // Emit each bucket as its own declaration in default -> namespace -> named order.
+            // We could be clever and merge certain combinations of import lines which would
+            // be legal grammar, but logic simplicity is better for maintainability.
+            if (defaultSpecifier) {
+                statements.push(buildImportDeclaration([defaultSpecifier], resourceName));
+            }
+            if (namespaceSpecifier) {
+                statements.push(buildImportDeclaration([namespaceSpecifier], resourceName));
+            }
+            if (namedSpecifiers.length > 0) {
+                statements.push(buildImportDeclaration(namedSpecifiers, resourceName));
             }
         }
     }

package/package.json

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

package/build/__tests__/adgAstGeneration.spec.d.ts

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

package/build/__tests__/adgAstGeneration.spec.js

@@ -1,447 +0,0 @@
-"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', () => {
-        const adg = (0, common_shared_1.initAdgMetadataObject)('adg0');
-        adg.requiredAdgFactoryFunctions.add(common_shared_1.IdKeys.ADG_FUNC);
-        const res = (0, functionAstGeneration_1.getAdgFunctionBody)(adg, moduleMetadata);
-        expect(res.body).toHaveLength(2);
-        expect(res.body[0].type).toBe('VariableDeclaration');
-        expect(res.body[1].type).toBe('ReturnStatement');
-    });
-    it('only contains a return statement if no factory functions are needed', () => {
-        const adg = (0, common_shared_1.initAdgMetadataObject)('adg0');
-        adg.requiredAdgFactoryFunctions.delete(common_shared_1.IdKeys.ADG_FUNC);
-        const res = (0, functionAstGeneration_1.getAdgFunctionBody)(adg, moduleMetadata);
-        expect(res.body).toHaveLength(1);
-        expect(res.body[0].type).toBe('ReturnStatement');
-    });
-});
-describe('composeAdgFunction', () => {
-    const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
-    it('can return a function declaration for a non exported function', () => {
-        const adg = (0, common_shared_1.initAdgMetadataObject)('adg0');
-        const res = (0, functionAstGeneration_1.composeAdgFunction)(adg, moduleMetadata);
-        expect(res.type).toBe('FunctionDeclaration');
-        expect(res.id.name).toBe('adg0');
-    });
-});
-describe('composeAdgStaticMetadata', () => {
-    it('creates a static metadata object', () => {
-        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
-        const adg = (0, common_shared_1.initAdgMetadataObject)('adg0');
-        adg.exportName = 'default';
-        moduleMetadata.staticMetadataId = 'c-test-comp';
-        const res = (0, functionAstGeneration_1.composeAdgStaticMetadata)(adg, moduleMetadata);
-        expect(res.type).toBe('VariableDeclaration');
-        const varDeclarator = res.declarations[0];
-        expect(varDeclarator.id.name).toBe('adg0Meta');
-        const properties = varDeclarator.init.properties;
-        expect(properties).toHaveLength(4);
-        expect(properties[0].value.value).toBe('c-test-comp');
-    });
-    it('creates a static metadata object for non default export', () => {
-        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
-        const adg = (0, common_shared_1.initAdgMetadataObject)('adg1');
-        adg.exportName = 'base';
-        moduleMetadata.staticMetadataId = 'c-test-comp';
-        const res = (0, functionAstGeneration_1.composeAdgStaticMetadata)(adg, moduleMetadata);
-        expect(res.type).toBe('VariableDeclaration');
-        const varDeclarator = res.declarations[0];
-        expect(varDeclarator.id.name).toBe('adg1Meta');
-        const properties = varDeclarator.init.properties;
-        expect(properties).toHaveLength(4);
-        expect(properties[0].value.value).toBe('c-test-comp__base');
-    });
-    describe('static metadata for component with image', () => {
-        const enablePropMetadata = [false, true];
-        for (const propMetadataEnabled of enablePropMetadata) {
-            it(`creates a static metadata object with child metadata ${propMetadataEnabled ? 'with props' : 'WITHOUT props'} and true for img`, () => {
-                const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
-                if (propMetadataEnabled) {
-                    moduleMetadata.includePropsMetadata = true;
-                }
-                const adg = (0, common_shared_1.initAdgMetadataObject)('adg0');
-                adg.exportName = 'default';
-                moduleMetadata.staticMetadataId = 'c-test-comp';
-                adg.compositionRootIndex = 0;
-                adg.compositions = [
-                    {
-                        type: 'Container',
-                        compositions: [
-                            {
-                                type: 'ComposedAdg',
-                                input: { type: 'ImportReference', value: 'test' },
-                                properties: {
-                                    attr1: { type: 'Binding', value: 'input1' },
-                                    attr2: { type: 'Binding', value: 'input2' },
-                                    attr3: { type: 'PrimitiveValue', value: 'Literal!' },
-                                },
-                            },
-                            {
-                                type: 'Image',
-                                src: { type: 'Binding', value: 'input1' },
-                            },
-                        ],
-                    },
-                ];
-                moduleMetadata.importIndexReference.set('test', 'import1');
-                moduleMetadata.importsByName.set('import1', {
-                    generatorAlias: 'i0',
-                    name: '',
-                    resourceName: '',
-                    komaciDocImportRef: '',
-                    isFromInternalNamespace: false,
-                    isFromSupportedLibrary: false,
-                    usedInPriming: false,
-                    staticallyAnalyzable: false,
-                });
-                const res = (0, functionAstGeneration_1.composeAdgStaticMetadata)(adg, moduleMetadata);
-                expect(res.type).toBe('VariableDeclaration');
-                const varDeclarator = res.declarations[0];
-                expect(varDeclarator.id.name).toBe('adg0Meta');
-                const properties = varDeclarator.init.properties;
-                expect(properties).toHaveLength(4);
-                expect(properties[0].value.value).toBe('c-test-comp');
-                expect(properties[1].value
-                    .properties[0].value.type).toBe('ArrayExpression');
-                const childMetaArr = properties[1].value
-                    .properties[0].value;
-                expect(childMetaArr.elements).toHaveLength(2);
-                // should have two elements, one for the adg ("a") and another for the props ("p")
-                // when propMetadata enabled; otherwise only 1 for the adg ("a")
-                const expectedNumElementsForChildMetadata = propMetadataEnabled ? 2 : 1;
-                expect(childMetaArr.elements[0].properties).toHaveLength(expectedNumElementsForChildMetadata);
-                expect(childMetaArr.elements[1].properties).toHaveLength(1);
-                expect(childMetaArr.elements[0].properties).toHaveLength(expectedNumElementsForChildMetadata);
-                const prop1 = childMetaArr.elements[0]
-                    .properties[0];
-                expect(prop1.value.name).toEqual('i0');
-                const prop2 = childMetaArr.elements[0]
-                    .properties[1];
-                if (propMetadataEnabled) {
-                    expect(prop2.value.properties).toHaveLength(3);
-                    const propObj = prop2.value.properties[0].value;
-                    expect(propObj.properties[1].value
-                        .value).toEqual('input1');
-                }
-                else {
-                    // no prop metadata if propMetadata is false
-                    expect(prop2).toBeUndefined();
-                }
-                expect(childMetaArr.elements[1].properties).toHaveLength(1);
-                expect(properties[3].value.value).toBeTruthy();
-            });
-        }
-    });
-    it('static meta data object has true for PF', () => {
-        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
-        const adg = (0, common_shared_1.initAdgMetadataObject)('adg0');
-        adg.exportName = 'default';
-        moduleMetadata.staticMetadataId = 'c-test-comp';
-        adg.compositionRootIndex = 0;
-        const primingFunction = {
-            requiredProperties: [],
-            importReference: { functionName: 'test' },
-            type: common_shared_1.FunctionTypes.PRIMING_FUNCTION,
-        };
-        adg.functions.push(primingFunction);
-        const res = (0, functionAstGeneration_1.composeAdgStaticMetadata)(adg, moduleMetadata);
-        expect(res.type).toBe('VariableDeclaration');
-        const varDeclarator = res.declarations[0];
-        expect(varDeclarator.id.name).toBe('adg0Meta');
-        const properties = varDeclarator.init.properties;
-        expect(properties).toHaveLength(4);
-        expect(properties[0].value.value).toBe('c-test-comp');
-        expect(properties[2].value.value).toBeTruthy();
-    });
-    it('static meta data object has true for PF for wire function', () => {
-        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
-        const adg = (0, common_shared_1.initAdgMetadataObject)('adg0');
-        adg.exportName = 'default';
-        moduleMetadata.staticMetadataId = 'c-test-comp';
-        adg.compositionRootIndex = 0;
-        const primingFunction = {
-            requiredProperties: [],
-            importReference: { functionName: 'test' },
-            type: common_shared_1.FunctionTypes.WIRE_FUNCTION,
-        };
-        adg.functions.push(primingFunction);
-        const res = (0, functionAstGeneration_1.composeAdgStaticMetadata)(adg, moduleMetadata);
-        expect(res.type).toBe('VariableDeclaration');
-        const varDeclarator = res.declarations[0];
-        expect(varDeclarator.id.name).toBe('adg0Meta');
-        const properties = varDeclarator.init.properties;
-        expect(properties).toHaveLength(4);
-        expect(properties[0].value.value).toBe('c-test-comp');
-        expect(properties[2].value.value).toBeTruthy();
-    });
-    it('static meta data object has false for PF for getter', () => {
-        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
-        const adg = (0, common_shared_1.initAdgMetadataObject)('adg0');
-        adg.exportName = 'default';
-        moduleMetadata.staticMetadataId = 'c-test-comp';
-        adg.compositionRootIndex = 0;
-        const primingFunction = {
-            requiredProperties: [],
-            type: common_shared_1.FunctionTypes.GETTER_FUNCTION,
-        };
-        adg.functions.push(primingFunction);
-        const res = (0, functionAstGeneration_1.composeAdgStaticMetadata)(adg, moduleMetadata);
-        expect(res.type).toBe('VariableDeclaration');
-        const varDeclarator = res.declarations[0];
-        expect(varDeclarator.id.name).toBe('adg0Meta');
-        const properties = varDeclarator.init.properties;
-        expect(properties).toHaveLength(4);
-        expect(properties[0].value.value).toBe('c-test-comp');
-        expect(properties[2].value.value).toBeFalsy();
-    });
-    it('Correct id for non exported class', () => {
-        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
-        const adg = (0, common_shared_1.initAdgMetadataObject)('adg0');
-        moduleMetadata.staticMetadataId = 'c-test-comp';
-        adg.compositionRootIndex = 0;
-        const primingFunction = {
-            requiredProperties: [],
-            type: common_shared_1.FunctionTypes.GETTER_FUNCTION,
-        };
-        adg.functions.push(primingFunction);
-        const res = (0, functionAstGeneration_1.composeAdgStaticMetadata)(adg, moduleMetadata);
-        expect(res.type).toBe('VariableDeclaration');
-        const varDeclarator = res.declarations[0];
-        expect(varDeclarator.id.name).toBe('adg0Meta');
-        const properties = varDeclarator.init.properties;
-        expect(properties).toHaveLength(4);
-        expect(properties[0].value.value).toBe('c-test-comp__$nonExportedClass$');
-        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();
-            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
-    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__/compile-generated-module-fixtures.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=compile-generated-module-fixtures.spec.d.ts.map

package/build/__tests__/compile-generated-module-fixtures.spec.js

@@ -1,49 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const glob_1 = require("glob");
-const sfdc_lwc_compiler_1 = require("@lwc-platform/sfdc-lwc-compiler");
-const compilerConfigs_1 = require("./compilerConfigs");
-const EXPECTED_SRC_FILENAME = 'expected.src';
-describe('fixtures', () => {
-    //Adding filter on the resolvable modules we try to compile until the compiler has been updated to handle imported gql queries. Will be removed in W-14269523
-    const fixtures = (0, glob_1.globSync)(path_1.default.resolve(__dirname, '**/expected.src')).filter((e) => !e.includes(`/fixtures-gql`));
-    for (const caseEntry of fixtures) {
-        const caseFolder = path_1.default.dirname(caseEntry);
-        const caseName = path_1.default.relative(__dirname, caseFolder);
-        const fixtureFilePath = (fileName) => {
-            return path_1.default.join(caseFolder, fileName);
-        };
-        const readFixtureFile = (fileName) => {
-            const filePath = fixtureFilePath(fileName);
-            return fs_1.default.existsSync(filePath) ? fs_1.default.readFileSync(filePath, 'utf-8') : null;
-        };
-        it(`${caseName}-komaci-module`, async () => {
-            const fileStr = readFixtureFile(EXPECTED_SRC_FILENAME);
-            expect(fileStr).not.toBeNull();
-            const files = { 'test.js': fileStr !== null ? fileStr : '' };
-            // Note: lockerConfig and compat outputConfig flags are mutually exclusive.
-            const result = await (0, sfdc_lwc_compiler_1.compile)({
-                bundle: {
-                    name: 'test',
-                    namespace: 'c',
-                    type: 'internal',
-                    files,
-                    options: {
-                        komaciOptions: {
-                            enableKomaci: false,
-                        },
-                    },
-                },
-                compilerConfigs: compilerConfigs_1.compilerConfigs,
-            });
-            expect(result.success).toBe(true);
-            expect(result.results).toHaveLength(compilerConfigs_1.compilerConfigs.length);
-        });
-    }
-});
-//# sourceMappingURL=compile-generated-module-fixtures.spec.js.map