@komaci/esm-generator 262.18.0 → 262.20.0

package/build/__tests__/adgAstGeneration.spec.js

@@ -363,7 +363,7 @@ export default class Component extends LightningElement {
         // Test that bundles with .ts files are processed correctly
         expect(() => {
             const bundleConfig = {
-                namespace: 'c',
+                namespace: 'lightning',
                 name: 'tsComponent',
                 type: 'internal',
                 namespaceMapping: {},

package/build/__tests__/functionAstGeneration.spec.js

@@ -328,14 +328,10 @@ describe('sanitizeFunction', () => {
         (0, functionAstGeneration_1.sanitizeFunction)(getters[0], imports, new Map());
         const hoisted = (0, types_1.functionDeclaration)((0, types_1.identifier)('g0'), [(0, types_1.identifier)('props')], getters[0].node.body);
         const generatedFunction = (0, generator_1.default)((0, types_1.file)((0, types_1.program)([hoisted])));
-        // The non-null assertion operator (!) should be removed
-        // Should generate: i0 && props.isVisible
-        // Should NOT generate: i0! && props.isVisible
-        expect(generatedFunction.code).not.toContain('!');
-        expect(generatedFunction.code).toContain('i0 && props.isVisible');
+        expect(generatedFunction.code).toContain('i0! && props.isVisible');
         expect(generatedFunction.code).toMatchInlineSnapshot(`
             "function g0(props) {
-              return i0 && props.isVisible;
+              return i0! && props.isVisible;
             }"
         `);
     });

package/build/__tests__/index.spec.js

@@ -301,7 +301,7 @@ describe('Bundle processing', () => {
         const input = {
             moduleInfo: {
                 name: 'test',
-                namespace: 'c',
+                namespace: 'lightning',
                 type: 'bundle',
                 files: bundleSrcFileMap,
             },
@@ -319,7 +319,7 @@ describe('Bundle processing', () => {
     it('can handle multiple script files with the same name in different directories', () => {
         const bundleSrcFileMap = {
             'test.js': {},
-            'subdir/test.ts': {},
+            'subdir/test.js': {},
             'test.html': {},
         };
         const input = {
@@ -331,7 +331,7 @@ describe('Bundle processing', () => {
             },
             srcFileMap: {
                 'test.js': 'export default class Test {}',
-                'subdir/test.ts': 'export default class Test {}',
+                'subdir/test.js': 'export default class Test {}',
                 'test.html': '<template><div>Test</div></template>',
                 'test.css': 'p { text-align: center; }',
             },
@@ -346,7 +346,7 @@ describe('Bundle processing', () => {
                 return 'test';
             }
         }`;
-        const fooTsSource = `export default class Foo {
+        const fooJsSource = `export default class Foo {
             get fooProp() {
                 return 'foo';
             }
@@ -357,7 +357,7 @@ describe('Bundle processing', () => {
             type: 'internal',
             files: [
                 { fileName: 'test.js', source: testJsSource },
-                { fileName: 'foo.ts', source: fooTsSource },
+                { fileName: 'foo.js', source: fooJsSource },
                 { fileName: 'test.html', source: '<template><div>Test</div></template>' },
                 { fileName: 'test.css', source: 'p { text-align: center; }' },
             ],
@@ -378,7 +378,7 @@ describe('Bundle processing', () => {
             },
             srcFileMap: {
                 'test.js': testJsSource,
-                'foo.ts': fooTsSource,
+                'foo.js': fooJsSource,
                 'test.html': '<template><div>Test</div></template>',
                 'test.css': 'p { text-align: center; }',
             },
@@ -389,5 +389,105 @@ describe('Bundle processing', () => {
         expect(res).toContain('testProp');
         expect(res).not.toContain('fooProp');
     });
+    it('can process typescript files in the lightning namespace', () => {
+        const testTsSource = `import { LightningElement } from 'lwc';
+
+        export default class TestComponent extends LightningElement {
+            private count: number = 0;
+
+            get doubleCount(): number {
+                return this.count * 2;
+            }
+
+            increment(): void {
+                this.count++;
+            }
+        }`;
+        const bundleConfig = {
+            namespace: 'lightning',
+            name: 'testComponent',
+            type: 'internal',
+            files: [
+                { fileName: 'testComponent.ts', source: testTsSource },
+                {
+                    fileName: 'testComponent.html',
+                    source: '<template><div>Test</div></template>',
+                },
+            ],
+            enableKomaci: true,
+            namespaceMapping: {},
+            npmModuleMapping: {},
+        };
+        const metadata = (0, metadata_1.collectBundleMetadata)(bundleConfig);
+        const inputFiles = Object.fromEntries(metadata.files
+            .map(({ fileName, komaciDoc }) => [fileName, komaciDoc])
+            .filter(([, komaciDoc]) => !!komaciDoc));
+        const input = {
+            moduleInfo: {
+                name: 'testComponent',
+                namespace: 'lightning',
+                type: 'bundle',
+                files: inputFiles,
+            },
+            srcFileMap: {
+                'testComponent.ts': testTsSource,
+                'testComponent.html': '<template><div>Test</div></template>',
+            },
+        };
+        const res = (0, __1.generateKomaciModule)(input);
+        expect(res).not.toContain('ErrorFunction');
+        expect(res).toContain('registerAdgFunction');
+        expect(res).toContain('doubleCount');
+    });
+    it('throws error for typescript files in non-lightning namespace', () => {
+        const testTsSource = `import { LightningElement } from 'lwc';
+
+        export default class TestComponent extends LightningElement {
+            private count: number = 0;
+
+            get doubleCount(): number {
+                return this.count * 2;
+            }
+
+            increment(): void {
+                this.count++;
+            }
+        }`;
+        const bundleConfig = {
+            namespace: 'c',
+            name: 'testComponent',
+            type: 'internal',
+            files: [
+                { fileName: 'testComponent.ts', source: testTsSource },
+                {
+                    fileName: 'testComponent.html',
+                    source: '<template><div>Test</div></template>',
+                },
+            ],
+            enableKomaci: true,
+            namespaceMapping: {},
+            npmModuleMapping: {},
+        };
+        const metadata = (0, metadata_1.collectBundleMetadata)(bundleConfig);
+        const inputFiles = Object.fromEntries(metadata.files
+            .map(({ fileName, komaciDoc }) => [fileName, komaciDoc])
+            .filter(([, komaciDoc]) => !!komaciDoc));
+        const input = {
+            moduleInfo: {
+                name: 'testComponent',
+                namespace: 'c',
+                type: 'bundle',
+                files: inputFiles,
+            },
+            srcFileMap: {
+                'testComponent.ts': testTsSource,
+                'testComponent.html': '<template><div>Test</div></template>',
+            },
+        };
+        const res = (0, __1.generateKomaciModule)(input);
+        // TypeScript files in non-lightning namespaces should now throw an error
+        expect(res).toContain('ErrorFunction');
+        expect(res).toContain('unsupported file extension: ts');
+    });
 });
 //# sourceMappingURL=index.spec.js.map

package/build/componentAstProcessing.d.ts

@@ -5,11 +5,12 @@ import { ModuleContext, ModuleMetadata, HoistedFunctionMetadata } from '@komaci/
 /**
  * Retrieve the file path for the js of a component
  * @param generatorState GeneratorState containg the GeneratorInput, which in turn contains the JS raw source file
+ * @param allowTypeScript Optional parameter to control whether TypeScript files should be considered. Defaults to true for backward compatibility.
  * @returns Returns raw source code as string for the js of a component if it exists in the srcFileMap
  *          Returns undefined if no JS source file (whose filename also matches the LWC module name) was included in the
  *          GeneratorState.GeneratorInput by lwc-platform, other calling code.
  */
-export declare function getComponentSrcJs(generatorInput: GeneratorInput): string | undefined;
+export declare function getComponentSrcJs(generatorInput: GeneratorInput, allowTypeScript?: boolean): string | undefined;
 /**
  * AST is traversed to see if they contain getter functions that are not valid. For each getter that is valid, we will
  * update contextual information about the class and pass back info about the valid getters.

package/build/componentAstProcessing.js

@@ -7,15 +7,17 @@ const common_shared_1 = require("@komaci/common-shared");
 /**
  * Retrieve the file path for the js of a component
  * @param generatorState GeneratorState containg the GeneratorInput, which in turn contains the JS raw source file
+ * @param allowTypeScript Optional parameter to control whether TypeScript files should be considered. Defaults to true for backward compatibility.
  * @returns Returns raw source code as string for the js of a component if it exists in the srcFileMap
  *          Returns undefined if no JS source file (whose filename also matches the LWC module name) was included in the
  *          GeneratorState.GeneratorInput by lwc-platform, other calling code.
  */
-function getComponentSrcJs(generatorInput) {
+function getComponentSrcJs(generatorInput, allowTypeScript = true) {
     let sourceCode;
     const moduleName = generatorInput.moduleInfo.name;
     if (generatorInput.srcFileMap) {
-        const filename = Object.keys(generatorInput.srcFileMap).find((filename) => (filename.endsWith('.js') || filename.endsWith('.ts')) &&
+        const filename = Object.keys(generatorInput.srcFileMap).find((filename) => (filename.endsWith('.js') ||
+            (filename.endsWith('.ts') && allowTypeScript)) &&
             filename.startsWith(moduleName));
         if (filename) {
             sourceCode = generatorInput.srcFileMap[filename];

package/build/functionAstGeneration.js

@@ -112,31 +112,6 @@ function sanitizeFunction(nodePath, importMetadata, gqlMetadataMap) {
                 path.replaceWith(t.memberExpression(t.identifier(common_shared_1.PROPS), path.node.property)); // replace this.<var> with props.<var>
             }
         },
-        // TypeScript type assertion and annotation removal
-        TSNonNullExpression(path) {
-            // Syntax: foo! - asserts foo is not null or undefined
-            path.replaceWith(path.node.expression);
-        },
-        TSAsExpression(path) {
-            // Syntax: (foo as string) - type assertion
-            path.replaceWith(path.node.expression);
-        },
-        TSTypeAssertion(path) {
-            // Syntax: (<string>foo) - angle-bracket type assertion
-            path.replaceWith(path.node.expression);
-        },
-        TSTypeAnnotation(path) {
-            // Syntax: const x: string or (param: string) - type annotations
-            path.remove();
-        },
-        TSTypeParameterInstantiation(path) {
-            // Syntax: Array<string>, foo<T>() - type parameter usage
-            path.remove();
-        },
-        TSTypeParameterDeclaration(path) {
-            // Syntax: function foo<T>(), class Bar<T> - type parameter declarations
-            path.remove();
-        },
         TaggedTemplateExpression(path) {
             const taggedTmplExpr = path.node;
             const taggedTmplLiteral = taggedTmplExpr.quasi;

package/build/index.js

@@ -86,6 +86,15 @@ function normalizeSrcFileKeys(input) {
     }
 }
 exports.normalizeSrcFileKeys = normalizeSrcFileKeys;
+/**
+ * Determines if TypeScript files should be processed for the given namespace.
+ * TypeScript files are only processed for lightning and lightning/interop namespaces.
+ * @param namespace the module namespace
+ * @returns true if TypeScript files should be processed
+ */
+function shouldProcessTypeScriptForNamespace(namespace) {
+    return namespace === 'lightning' || namespace.startsWith('lightning/interop');
+}
 /**
  * Helper function to process and build the resolvable module based off the generator input and inital generator state.
  * @param input the Generator input
@@ -97,14 +106,16 @@ function processGeneratorInputAndState(input) {
         // Determine file type based on extension in file name.
         const segments = (0, common_shared_1.getFilepathSegments)(input.moduleInfo.fileName);
         const fileExt = segments[segments.length - 1];
+        const namespace = input.moduleInfo.namespace;
+        const isTypeScriptAllowed = shouldProcessTypeScriptForNamespace(namespace);
         let sourceFile;
-        const source = (0, componentAstProcessing_1.getComponentSrcJs)(input);
+        const source = (0, componentAstProcessing_1.getComponentSrcJs)(input, isTypeScriptAllowed);
         if (fileExt === 'html') {
             const templateMap = {};
             templateMap[input.moduleInfo.name] = input.moduleInfo.komaciDoc;
             sourceFile = (0, genericAstGeneration_1.generateResolvableModule)(input, undefined, templateMap, source);
         }
-        else if (fileExt === 'js' || fileExt === 'ts') {
+        else if (fileExt === 'js' || (fileExt === 'ts' && isTypeScriptAllowed)) {
             sourceFile = (0, genericAstGeneration_1.generateResolvableModule)(input, input.moduleInfo.komaciDoc, undefined, source);
         }
         else {
@@ -116,6 +127,8 @@ function processGeneratorInputAndState(input) {
     else if (input.moduleInfo.type === 'bundle') {
         // code to process a bundle
         let filename = '', fileExt;
+        const namespace = input.moduleInfo.namespace;
+        const isTypeScriptAllowed = shouldProcessTypeScriptForNamespace(namespace);
         const scriptDocs = {}; // {'test.js' : { filename: 'test', komaciDoc: KomaciDoc1 }}
         const htmlDocs = {};
         let sourceFile;
@@ -127,14 +140,14 @@ function processGeneratorInputAndState(input) {
             if (fileExt == 'html') {
                 htmlDocs[filename] = komaciDoc;
             }
-            else if (fileExt === 'js' || fileExt === 'ts') {
+            else if (fileExt === 'js' || (fileExt === 'ts' && isTypeScriptAllowed)) {
                 scriptDocs[filePath] = { filename, komaciDoc };
             }
             else {
                 throw new Error(types_1.ERROR_PREFIX + 'unsupported file extension: ' + fileExt);
             }
         }
-        const source = (0, componentAstProcessing_1.getComponentSrcJs)(input);
+        const source = (0, componentAstProcessing_1.getComponentSrcJs)(input, isTypeScriptAllowed);
         // Find the main component script file(s)
         const mainComponentScriptFiles = Object.values(scriptDocs).filter(({ filename }) => filename === input.moduleInfo.name);
         // For now we only support one main component script file.

package/package.json

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

package/build/__tests__/komaci-typescript-syntax.spec.d.ts

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

package/build/__tests__/komaci-typescript-syntax.spec.js

@@ -1,481 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const parser_1 = require("@babel/parser");
-const traverse_1 = __importDefault(require("@babel/traverse"));
-const generator_1 = __importDefault(require("@babel/generator"));
-const functionAstGeneration_1 = require("../functionAstGeneration");
-/**
- * Helper function to parse TypeScript code and extract a class method/property
- * for testing sanitizeFunction
- */
-function parseAndExtractClassMember(code) {
-    const ast = (0, parser_1.parse)(code, {
-        sourceType: 'module',
-        plugins: ['typescript', 'classProperties'],
-    });
-    let targetPath = null;
-    (0, traverse_1.default)(ast, {
-        ClassMethod(path) {
-            if (!targetPath) {
-                targetPath = path;
-            }
-        },
-        ClassProperty(path) {
-            if (!targetPath) {
-                targetPath = path;
-            }
-        },
-    });
-    return targetPath;
-}
-/**
- * Helper to sanitize and generate code from a TypeScript class member
- */
-function sanitizeAndGenerate(code) {
-    const memberPath = parseAndExtractClassMember(code);
-    if (!memberPath) {
-        throw new Error('No class member found in code');
-    }
-    const importMetadata = new Map();
-    const gqlMetadata = new Map();
-    (0, functionAstGeneration_1.sanitizeFunction)(memberPath, importMetadata, gqlMetadata);
-    return (0, generator_1.default)(memberPath.node).code;
-}
-/**
- * Helper to assert that code is valid JavaScript (no TypeScript syntax).
- * Wraps method code in a minimal class structure for parsing.
- * Throws if the code cannot be parsed as plain JavaScript.
- */
-function assertValidJavaScript(methodCode) {
-    // Wrap the method in a class so it's parseable as standalone JS
-    const wrappedCode = `class TestClass { ${methodCode} }`;
-    try {
-        (0, parser_1.parse)(wrappedCode, {
-            sourceType: 'module',
-            plugins: [], // No TypeScript plugin - must be valid JS
-        });
-    }
-    catch (error) {
-        throw new Error(`Generated code is not valid JavaScript:\n${methodCode}\n\nParse error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-describe('sanitizeFunction - Direct TypeScript Syntax Stripping Tests', () => {
-    describe('TSNonNullExpression - Non-null assertion (!)', () => {
-        it('should remove non-null assertion from return statement', () => {
-            const code = `
-class Test {
-    get value() {
-        return this.data!;
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).toContain('props.data');
-            expect(result).not.toContain('!');
-            assertValidJavaScript(result);
-        });
-        it('should remove chained non-null assertions', () => {
-            const code = `
-class Test {
-    get value() {
-        return this.data!.name!.value;
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain('!');
-            expect(result).toContain('props.data.name.value');
-            assertValidJavaScript(result);
-        });
-        it('should remove non-null in array access', () => {
-            const code = `
-class Test {
-    get first() {
-        return this.items![0];
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain('!');
-            expect(result).toContain('props.items[0]');
-            assertValidJavaScript(result);
-        });
-    });
-    describe('TSAsExpression - Type assertions (as)', () => {
-        it('should remove simple as expression', () => {
-            const code = `
-class Test {
-    get stringValue() {
-        return this.value as string;
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(' as ');
-            expect(result).toContain('props.value');
-        });
-        it('should remove double as cast (as unknown as Type)', () => {
-            const code = `
-class Test {
-    get boolValue() {
-        return (this.value as unknown) as boolean;
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(' as ');
-            expect(result).toContain('props.value');
-        });
-        it('should remove as with complex object type', () => {
-            const code = `
-class Test {
-    get config() {
-        return this.data as { name: string; value: number };
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(' as ');
-            expect(result).toContain('props.data');
-        });
-        it('should remove as in arrow function parameters', () => {
-            const code = `
-class Test {
-    get mapped() {
-        return this.items.map((item: any, index: number) => (item as string));
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(' as string');
-            expect(result).not.toContain(': any');
-            expect(result).not.toContain(': number');
-        });
-    });
-    describe('TSTypeAssertion - Angle-bracket assertions (<Type>)', () => {
-        it('should remove angle-bracket type assertion', () => {
-            const code = `
-class Test {
-    get value() {
-        return (<string>this.data);
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain('<string>');
-            expect(result).toContain('props.data');
-        });
-        it('should remove nested angle-bracket assertions', () => {
-            const code = `
-class Test {
-    get value() {
-        return (<any>(<string>this.data));
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain('<any>');
-            expect(result).not.toContain('<string>');
-            expect(result).toContain('props.data');
-        });
-    });
-    describe('TSTypeAnnotation - Type annotations', () => {
-        it('should remove type annotation from variable', () => {
-            const code = `
-class Test {
-    get items() {
-        const list: string[] = [];
-        return list;
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(': string[]');
-            expect(result).toContain('const list = []');
-        });
-        it('should remove type annotations from function parameters', () => {
-            const code = `
-class Test {
-    get transformed() {
-        return this.data.map((item: string, index: number) => item + index);
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(': string');
-            expect(result).not.toContain(': number');
-            expect(result).toContain('(item, index)');
-        });
-        it('should remove complex type annotations', () => {
-            const code = `
-class Test {
-    get complexData() {
-        const data: { name: string; values: number[] } = this.config;
-        return data;
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(': {');
-            expect(result).toContain('const data = props.config');
-        });
-        it('should remove type annotation with typeof', () => {
-            const code = `
-class Test {
-    get mapped() {
-        return this.items.map((item: typeof this.config) => item);
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain('typeof');
-            expect(result).not.toContain(': typeof');
-            expect(result).toContain('item => item');
-        });
-        it('should remove type annotation with keyof', () => {
-            const code = `
-class Test {
-    get keys() {
-        return this.list.map((key: keyof typeof this.data) => key);
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain('keyof');
-            expect(result).not.toContain(': keyof');
-            expect(result).toContain('key => key');
-        });
-    });
-    describe('TSTypeParameterInstantiation - Generic type arguments', () => {
-        it('should remove generic type arguments from Array', () => {
-            const code = `
-class Test {
-    get items() {
-        return Array<string>();
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain('<string>');
-            expect(result).toContain('Array()');
-        });
-        it('should remove generic type arguments from function calls', () => {
-            const code = `
-class Test {
-    get converted() {
-        return this.convert<number, string>(this.value);
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain('<number');
-            expect(result).not.toContain('<string>');
-            expect(result).toContain('props.convert(props.value)');
-        });
-        it('should remove nested generic types', () => {
-            const code = `
-class Test {
-    get matrix() {
-        return Array<Array<number>>();
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain('<Array<number>>');
-            expect(result).toContain('Array()');
-        });
-    });
-    describe('TSTypeParameterDeclaration - Generic type parameters', () => {
-        it('should remove generic type parameter from method', () => {
-            const code = `
-class Test {
-    transform<T>(value: T): T {
-        return value;
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain('<T>');
-            expect(result).not.toContain(': T');
-            expect(result).toContain('transform(value)');
-        });
-        it('should remove multiple generic type parameters', () => {
-            const code = `
-class Test {
-    map<T, U>(input: T, fn: (x: T) => U): U {
-        return fn(input);
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain('<T, U>');
-            expect(result).not.toContain(': T');
-            expect(result).not.toContain(': U');
-            expect(result).toContain('map(input, fn)');
-        });
-        it('should remove generic with extends constraint', () => {
-            const code = `
-class Test {
-    process<T extends { id: string }>(item: T) {
-        return item.id;
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain('<T extends');
-            expect(result).not.toContain(': T');
-            expect(result).toContain('process(item)');
-        });
-    });
-    describe('Real-world patterns from failing modules', () => {
-        it('should handle pattern from lightning/formattedPhone', () => {
-            const code = `
-class Test {
-    get hasValue() {
-        return this.value != null && ((this.value as unknown) as string) !== '';
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(' as ');
-            expect(result).toContain('props.value != null');
-            expect(result).toContain("!== ''");
-            assertValidJavaScript(result);
-        });
-        it('should handle pattern from appexchange/agenticContent', () => {
-            const code = `
-class Test {
-    get formattedList() {
-        const list = this.items || [];
-        return list.map((item: any, index: number) => ({ 
-            ...item,
-            accordionId: \`accordion-\${index}\`,
-            key: \`item-\${index}\`
-        }));
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(': any');
-            expect(result).not.toContain(': number');
-            expect(result).toContain('(item, index)');
-            assertValidJavaScript(result);
-        });
-        it('should handle pattern from lightning/tabBar', () => {
-            const code = `
-class Test {
-    get hiddenTargets() {
-        const hiddenTargets: string[] = [];
-        this.allTabs.forEach(tab => {
-            if (!tab.visible && tab.targetSelectionName) {
-                hiddenTargets.push(tab.targetSelectionName);
-            }
-        });
-        return hiddenTargets;
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(': string[]');
-            expect(result).toContain('const hiddenTargets = []');
-            assertValidJavaScript(result);
-        });
-        it('should handle pattern from lightning/modalBase with destructuring', () => {
-            const code = `
-class Test {
-    get dimensions() {
-        const {
-            height,
-            width
-        } = (this.backdropRect as {
-            height?: number;
-            width?: number;
-        });
-        return { height, width };
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(' as ');
-            expect(result).not.toContain('height?:');
-            expect(result).not.toContain('width?:');
-            expect(result).toContain('props.backdropRect');
-            assertValidJavaScript(result);
-        });
-        it('should handle pattern from lightning/outputField', () => {
-            const code = `
-class Test {
-    get latitude() {
-        return (this.uiField.value as {
-            latitude?: number | string;
-        }).latitude;
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(' as ');
-            expect(result).not.toContain('latitude?:');
-            expect(result).toContain('props.uiField.value');
-            expect(result).toContain('.latitude');
-            assertValidJavaScript(result);
-        });
-        it('should handle pattern from schedulingPolicyObjectHome with as const', () => {
-            const code = `
-class Test {
-    get config() {
-        return ({
-            apiVersion: "60.0",
-            scope: "LIST",
-            regionWidth: "LARGE"
-        } as const);
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain('as const');
-            expect(result).toContain('apiVersion: "60.0"');
-            assertValidJavaScript(result);
-        });
-        it('should handle pattern from analytics_share/shareModal with optional chaining', () => {
-            const code = `
-class Test {
-    get platform() {
-        return (this.componentData as any)?.platform || 'Tableau';
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(' as any');
-            expect(result).toContain('props.componentData');
-            expect(result).toContain('?.platform');
-            assertValidJavaScript(result);
-        });
-    });
-    describe('Combined and nested TypeScript constructs', () => {
-        it('should handle multiple TypeScript features in one expression', () => {
-            const code = `
-class Test {
-    get complex() {
-        const items: string[] = this.data!;
-        return items.map((item: any, index: number) => ({
-            ...item,
-            id: (index as number)
-        } as const));
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(': string[]');
-            expect(result).not.toContain('!');
-            expect(result).not.toContain(': any');
-            expect(result).not.toContain(': number');
-            expect(result).not.toContain(' as number');
-            expect(result).not.toContain('as const');
-            assertValidJavaScript(result);
-        });
-        it('should handle deeply nested TypeScript syntax', () => {
-            const code = `
-class Test {
-    get nested() {
-        return (this.data! as Array<string>).map((x: string) => (x as any));
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain('!');
-            expect(result).not.toContain(' as Array');
-            expect(result).not.toContain(': string');
-            expect(result).not.toContain(' as any');
-            assertValidJavaScript(result);
-        });
-    });
-    describe('Edge cases', () => {
-        it('should handle return type annotation on arrow function', () => {
-            const code = `
-class Test {
-    get transformed() {
-        return this.items.map((x: string): string => x.toUpperCase());
-    }
-}`;
-            const result = sanitizeAndGenerate(code);
-            expect(result).not.toContain(': string');
-            expect(result).toContain('x => x.toUpperCase()');
-        });
-    });
-});
-//# sourceMappingURL=komaci-typescript-syntax.spec.js.map