@komaci/esm-generator 262.16.0 → 262.18.0

package/build/__tests__/index.spec.js

@@ -25,6 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const __1 = require("..");
 const modgen = __importStar(require("../genericAstGeneration"));
+const metadata_1 = require("@lwc/metadata");
 describe('Handling errors that throw inside a call to generateKomaciModule', () => {
     it('should return error adg when an error is produced', () => {
         const input = {
@@ -290,4 +291,103 @@ describe('normalizeSrcFileKeys', () => {
         expect(input.srcFileMap['templates/test2.html']).not.toBeUndefined();
     });
 });
+describe('Bundle processing', () => {
+    it('when both .js and .ts files exist with for the component name', () => {
+        const bundleSrcFileMap = {
+            'test.js': {},
+            'test.ts': {},
+            'test.html': {},
+        };
+        const input = {
+            moduleInfo: {
+                name: 'test',
+                namespace: 'c',
+                type: 'bundle',
+                files: bundleSrcFileMap,
+            },
+            srcFileMap: {
+                'test.js': 'export default class Test {}',
+                'test.ts': 'export default class Test {}',
+                'test.html': '<template><div>Test</div></template>',
+                'test.css': 'p { text-align: center; }',
+            },
+        };
+        const res = (0, __1.generateKomaciModule)(input);
+        expect(res).toContain('ErrorFunction');
+        expect(res).toContain('[komaci esm-generator] multiple component script files with the same name found in bundle: test');
+    });
+    it('can handle multiple script files with the same name in different directories', () => {
+        const bundleSrcFileMap = {
+            'test.js': {},
+            'subdir/test.ts': {},
+            'test.html': {},
+        };
+        const input = {
+            moduleInfo: {
+                name: 'test',
+                namespace: 'c',
+                type: 'bundle',
+                files: bundleSrcFileMap,
+            },
+            srcFileMap: {
+                'test.js': 'export default class Test {}',
+                'subdir/test.ts': 'export default class Test {}',
+                'test.html': '<template><div>Test</div></template>',
+                'test.css': 'p { text-align: center; }',
+            },
+        };
+        const res = (0, __1.generateKomaciModule)(input);
+        expect(res).not.toContain('ErrorFunction');
+        expect(res).toContain('registerAdgFunction');
+    });
+    it('can handle multiple script files with different names in same directory', () => {
+        const testJsSource = `export default class Test extends LightningElement {
+            get testProp() {
+                return 'test';
+            }
+        }`;
+        const fooTsSource = `export default class Foo {
+            get fooProp() {
+                return 'foo';
+            }
+        }`;
+        const bundleConfig = {
+            namespace: 'c',
+            name: 'test',
+            type: 'internal',
+            files: [
+                { fileName: 'test.js', source: testJsSource },
+                { fileName: 'foo.ts', source: fooTsSource },
+                { fileName: 'test.html', source: '<template><div>Test</div></template>' },
+                { fileName: 'test.css', source: 'p { text-align: center; }' },
+            ],
+            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: 'test',
+                namespace: 'c',
+                type: 'bundle',
+                files: inputFiles,
+            },
+            srcFileMap: {
+                'test.js': testJsSource,
+                'foo.ts': fooTsSource,
+                'test.html': '<template><div>Test</div></template>',
+                'test.css': 'p { text-align: center; }',
+            },
+        };
+        const res = (0, __1.generateKomaciModule)(input);
+        expect(res).not.toContain('ErrorFunction');
+        expect(res).toContain('registerAdgFunction');
+        expect(res).toContain('testProp');
+        expect(res).not.toContain('fooProp');
+    });
+});
 //# sourceMappingURL=index.spec.js.map

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

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

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

@@ -0,0 +1,481 @@
+"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

package/build/functionAstGeneration.js

@@ -112,11 +112,31 @@ 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 like foo! is a TypeScript syntax that means "foo is not null or undefined"
-            // we need to remove the ! to make the code valid JavaScript
+            // 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

@@ -116,38 +116,36 @@ function processGeneratorInputAndState(input) {
     else if (input.moduleInfo.type === 'bundle') {
         // code to process a bundle
         let filename = '', fileExt;
-        const docMap = input.moduleInfo.files; // {'test.html' : KomaciDoc1, 'test.js' : KomaciDoc2}
-        const filesMap = {}; // {'html' : {'test.html' : KomaciDoc1}, 'js' : {'test.js' : KomaciDoc2 }}
+        const scriptDocs = {}; // {'test.js' : { filename: 'test', komaciDoc: KomaciDoc1 }}
+        const htmlDocs = {};
         let sourceFile;
-        for (const [fullFilename, komaciDoc] of Object.entries(docMap)) {
+        for (const [filePath, komaciDoc] of Object.entries(input.moduleInfo.files)) {
             // Determine file type based on extension in file name.
-            const segments = (0, common_shared_1.getFilepathSegments)(fullFilename);
+            const segments = (0, common_shared_1.getFilepathSegments)(filePath);
             filename = segments[0]; // the filename, up to but not including, the file separator character
             fileExt = segments[segments.length - 1]; // filename extension, not including the separator
-            let filesObj = {};
-            // check for existing map entry in order to append to it
-            // to support multiple files per filetype in the future
-            if (filesMap[fileExt]) {
-                filesObj = filesMap[fileExt];
-            }
-            filesObj[filename] = komaciDoc;
             if (fileExt == 'html') {
-                filesMap['html'] = filesObj;
+                htmlDocs[filename] = komaciDoc;
             }
             else if (fileExt === 'js' || fileExt === 'ts') {
-                filesMap['js'] = filesObj;
+                scriptDocs[filePath] = { filename, komaciDoc };
             }
             else {
                 throw new Error(types_1.ERROR_PREFIX + 'unsupported file extension: ' + fileExt);
             }
         }
         const source = (0, componentAstProcessing_1.getComponentSrcJs)(input);
-        const komaciJSDoc = filesMap && filesMap['js'] && filesMap['js'][input.moduleInfo.name]
-            ? filesMap['js'][input.moduleInfo.name]
-            : {};
-        const komaciHtmlDocMap = filesMap && filesMap['html'] ? filesMap['html'] : {};
+        // 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.
+        if (mainComponentScriptFiles.length > 1) {
+            throw new Error(types_1.ERROR_PREFIX +
+                'multiple component script files with the same name found in bundle: ' +
+                input.moduleInfo.name);
+        }
+        const uniqueMainComponentScriptDoc = mainComponentScriptFiles[0]?.komaciDoc ?? {};
         // eslint-disable-next-line prefer-const
-        sourceFile = (0, genericAstGeneration_1.generateResolvableModule)(input, komaciJSDoc, komaciHtmlDocMap, source);
+        sourceFile = (0, genericAstGeneration_1.generateResolvableModule)(input, uniqueMainComponentScriptDoc, htmlDocs, source);
         // Generate source from constructed AST.
         const babelOutput = (0, generator_1.default)(sourceFile);
         return babelOutput.code;

package/package.json

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