@komaci/esm-generator 262.15.0 → 262.17.0

package/build/__tests__/functionAstGeneration.spec.js

@@ -303,6 +303,42 @@ describe('sanitizeFunction', () => {
     it('should throw an error if we try to reference a bad input', () => {
         expect(() => (0, functionAstGeneration_1.sanitizeFunction)(getters[1], imports, new Map())).toThrowError(new Error(`${common_shared_1.ERROR_PREFIX}: 'bad' does not map to valid import`));
     });
+    it('should strip TypeScript non-null assertion operator (!)', () => {
+        const sourceWithNonNull = `
+            import accessCheck from '@salesforce/accessCheck/SomeCheck.enabled';
+            export default class TestComponent {
+                get showContent() {
+                    return accessCheck! && this.isVisible;
+                }
+            }
+        `;
+        const ast = (0, common_shared_1.generateAstFromSrcCode)(sourceWithNonNull);
+        const { getters } = (0, common_shared_1.getPropertyMetadataFromAst)(ast);
+        const imports = new Map();
+        imports.set('accessCheck', {
+            name: 'accessCheck',
+            resourceName: '@salesforce/accessCheck/SomeCheck.enabled',
+            staticallyAnalyzable: false,
+            usedInPriming: true,
+            isFromInternalNamespace: true,
+            isFromSupportedLibrary: true,
+            generatorAlias: 'i0',
+            komaciDocImportRef: '0/names/0',
+        });
+        (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).toMatchInlineSnapshot(`
+            "function g0(props) {
+              return i0 && props.isVisible;
+            }"
+        `);
+    });
 });
 describe('adgToExpression', () => {
     it('returns valid adg function from komaci doc', () => {

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/functionAstGeneration.js

@@ -112,6 +112,11 @@ function sanitizeFunction(nodePath, importMetadata, gqlMetadataMap) {
                 path.replaceWith(t.memberExpression(t.identifier(common_shared_1.PROPS), path.node.property)); // replace this.<var> with props.<var>
             }
         },
+        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
+            path.replaceWith(path.node.expression);
+        },
         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.15.0",
+    "version": "262.17.0",
     "description": "Komaci generator for ADG ES modules",
     "homepage": "https://komaci.dev/",
     "repository": {