npm - @komaci/esm-generator - Versions diffs - 240.1.3 - Mend

@komaci/esm-generator 240.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (111) hide show

package/build/__tests__/komaci-ast-unit.spec.js ADDED Viewed

@@ -0,0 +1,628 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_1 = require("../shared");
+const generalMockSourceCode_1 = require("./fixtures-source-code/generalMockSourceCode");
+const modGenScript_1 = require("../modGenScript");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const core_1 = require("@babel/core");
+const validationStuff_1 = __importDefault(require("./general-komaci-docs/import-types/validationStuff"));
+const generator_1 = __importDefault(require("@babel/generator"));
+const common_shared_1 = require("@komaci/common-shared");
+const initGeneratorInput = () => {
+    const filesMap = {};
+    filesMap['test.js'] = {
+        exports: { 'test.js': { type: 'AdgReference', value: 0 } },
+    };
+    filesMap['test.html'] = {
+        exports: { 'test.html': { type: 'CompositionReference', value: 0 } },
+    };
+    filesMap['test.css'] = {
+        exports: { 'test.css': { type: 'CompositionReference', value: 0 } },
+    };
+    return {
+        moduleInfo: {
+            name: 'test',
+            namespace: 'lightning',
+            type: 'bundle',
+            files: filesMap,
+        },
+        srcFileMap: {
+            'test.js': 'console.log("hi");',
+            'test.css': 'p { text-align: center; }',
+            'test.html': '<html><body><h1>Hey</h1></body></html>',
+        },
+    };
+};
+const initGeneratorState = (input) => ({
+    input,
+    adgImportSuffix: 0,
+    importAliasSuffix: 0,
+    scriptGenState: {
+        importRefsMap: {},
+        requiredFactoryFunctions: new Set([]),
+        importInfosForWireAdapter: new Set([]),
+        primingAdapterImportDeclarations: [],
+    },
+    templateGenState: {
+        importRefsMap: {},
+        requiredFactoryFunctions: new Set(),
+        refProps: new Set(),
+    },
+    iterationContext: [],
+    defaultCompImported: true,
+    adgNameMap: {},
+    isDefaultExportFound: true,
+});
+const collectResolutionModuleReturn = (ast) => {
+    const program = ast.program;
+    const body = program.body;
+    const defaultExport = body.filter((dec) => dec.type === 'ExportDefaultDeclaration')[0];
+    const defExp_declaration = defaultExport.declaration;
+    return defExp_declaration.body.body.filter((stmt) => stmt.type === 'ReturnStatement')[0];
+};
+const collectAdgFunctionArgs = (resolvableModuleReturn) => {
+    const adgFunctionArgs = resolvableModuleReturn.argument
+        .arguments;
+    expect(adgFunctionArgs).not.toBeUndefined();
+    expect(adgFunctionArgs).toHaveLength(5);
+    return {
+        parent: adgFunctionArgs[0],
+        properties: adgFunctionArgs[1],
+        functions: adgFunctionArgs[2],
+        composition: adgFunctionArgs[3],
+        childDependencies: adgFunctionArgs[4],
+    };
+};
+const collectModuleLevelFunctionDeclaration = (ast) => {
+    const body = ast?.program.body;
+    expect(body).not.toBeUndefined();
+    return body?.filter((statement) => statement.type === 'FunctionDeclaration');
+};
+const validateFunctions = (ast, functions) => {
+    const visitors = {
+        FunctionDeclaration: (path) => {
+            if (path.node.id) {
+                const functionInfo = functions.find((f) => f.compiledName === path.node.id.name);
+                if (functionInfo) {
+                    path.traverse(validateImportInflation(functionInfo.usedImports));
+                    const composedFunction = (0, generator_1.default)(path.node).code;
+                    expect(composedFunction).toBe(functionInfo.expectedOutput);
+                }
+            }
+        },
+    };
+    (0, core_1.traverse)(ast, visitors);
+};
+const validateImportInflation = (invalidKeys) => ({
+    Identifier(path) {
+        if ((path.parent.type === 'MemberExpression' &&
+            path.parent.object === path.node) ||
+            (path.parent.type === 'CallExpression' && path.parent.callee == path.node) ||
+            (path.parent.type !== 'CallExpression' &&
+                path.parent.type !== 'MemberExpression')) {
+            expect(invalidKeys.includes(path.node.name)).toBeFalsy();
+        }
+    },
+});
+const validateImport = (ast, resourcePath, expected) => {
+    const importNode = ast.program.body.find((item) => item.type === 'ImportDeclaration' && item.source.value === resourcePath);
+    expect(importNode).not.toBeUndefined();
+    expect((0, generator_1.default)(importNode).code).toBe(expected);
+};
+describe('getAstFromGenStateRawSrc', () => {
+    it('should handle LWC modules with multiple file types and multiple JS files', () => {
+        const filesMap = {};
+        filesMap['test.js'] = {
+            exports: { 'test.js': { type: 'AdgReference', value: 0 } },
+        };
+        filesMap['test.html'] = {
+            exports: { 'test.html': { type: 'CompositionReference', value: 0 } },
+        };
+        filesMap['test.css'] = {
+            exports: { 'test.css': { type: 'CompositionReference', value: 0 } },
+        };
+        filesMap['somethingElse.js'] = {
+            exports: { 'somethingElse.js': { type: 'AdgReference', value: 0 } },
+        };
+        const input = {
+            moduleInfo: {
+                name: 'test',
+                namespace: 'c',
+                type: 'bundle',
+                files: filesMap,
+            },
+            srcFileMap: {
+                'test.js': 'console.log("hi");',
+                'somethingElse.js': 'eval("bye")',
+                'test.css': 'p { text-align: center; }',
+                'test.html': '<html><body><h1>Hey</h1></body></html>',
+            },
+        };
+        const generatorState = initGeneratorState(input);
+        const srcCode = (0, shared_1.getComponentSrcJs)(generatorState);
+        expect(srcCode).not.toBeUndefined();
+        expect(srcCode).toEqual(input.srcFileMap?.['test.js']);
+    });
+});
+describe('proccessGetters', () => {
+    const filesMap = {};
+    filesMap['test.js'] = {
+        exports: { 'test.js': { type: 'AdgReference', value: 0 } },
+    };
+    filesMap['test.html'] = {
+        exports: { 'test.html': { type: 'CompositionReference', value: 0 } },
+    };
+    filesMap['test.css'] = {
+        exports: { 'test.css': { type: 'CompositionReference', value: 0 } },
+    };
+    filesMap['somethingElse.js'] = {
+        exports: { 'somethingElse.js': { type: 'AdgReference', value: 0 } },
+    };
+    it('should process and return only the valid getter', () => {
+        const input = {
+            moduleInfo: {
+                name: 'test',
+                namespace: 'lightning',
+                type: 'bundle',
+                files: filesMap,
+            },
+            srcFileMap: {
+                'test.js': generalMockSourceCode_1.mockOneBadGetter,
+                'somethingElse.js': 'eval("bye")',
+                'test.css': 'p { text-align: center; }',
+                'test.html': '<html><body><h1>Hey</h1></body></html>',
+            },
+        };
+        const generatorState = initGeneratorState(input);
+        const properties = new Map();
+        properties.set('searchKey', {
+            type: common_shared_1.PropertyTypes.GETTER,
+            usedInPriming: true,
+        });
+        properties.set('perfectlyGood', {
+            type: common_shared_1.PropertyTypes.GETTER,
+            usedInPriming: true,
+        });
+        const src = (0, shared_1.getComponentSrcJs)(generatorState);
+        const moduleLevelConsumption = {
+            consumedImports: new Map(),
+        };
+        expect(src).not.toBeUndefined();
+        const ast = (0, common_shared_1.generateAstFromSrcCode)(src);
+        generatorState.scriptGenState.ast = ast;
+        const moduleContext = {
+            astContext: (0, common_shared_1.getAstContextObject)(ast),
+            isExternal: (0, common_shared_1.isExternalModule)(generatorState.input.moduleInfo.namespace),
+        };
+        generatorState.scriptGenState.importMetadata =
+            moduleContext.astContext.importDeclarations;
+        const { getters } = (0, common_shared_1.getPropertyMetadataFromAst)(ast);
+        const res = (0, shared_1.processGetters)(properties, moduleContext, moduleLevelConsumption, getters);
+        expect(res).not.toBeUndefined();
+        expect(res).toHaveLength(1);
+        expect(res[0].memberUsage).toHaveLength(1);
+    });
+    it('should process and return empty array for no valid getters', () => {
+        const input = {
+            moduleInfo: {
+                name: 'test',
+                namespace: 'lightning',
+                type: 'bundle',
+                files: filesMap,
+            },
+            srcFileMap: {
+                'test.js': generalMockSourceCode_1.mockOnlyBadGetter,
+                'somethingElse.js': 'eval("bye")',
+                'test.css': 'p { text-align: center; }',
+                'test.html': '<html><body><h1>Hey</h1></body></html>',
+            },
+        };
+        const generatorState = initGeneratorState(input);
+        const properties = new Map();
+        properties.set('searchKey', {
+            type: common_shared_1.PropertyTypes.GETTER,
+            usedInPriming: true,
+        });
+        const src = (0, shared_1.getComponentSrcJs)(generatorState);
+        const moduleLevelConsumption = {
+            consumedImports: new Map(),
+        };
+        expect(src).not.toBeUndefined();
+        const ast = (0, common_shared_1.generateAstFromSrcCode)(src);
+        generatorState.scriptGenState.ast = ast;
+        const moduleContext = {
+            astContext: (0, common_shared_1.getAstContextObject)(ast),
+            isExternal: (0, common_shared_1.isExternalModule)(generatorState.input.moduleInfo.namespace),
+        };
+        generatorState.scriptGenState.importMetadata =
+            moduleContext.astContext.importDeclarations;
+        const { getters } = (0, common_shared_1.getPropertyMetadataFromAst)(ast);
+        const res = (0, shared_1.processGetters)(properties, moduleContext, moduleLevelConsumption, getters);
+        expect(res).not.toBeUndefined();
+        expect(res).toHaveLength(0);
+    });
+    it('should process and return only getter with just return when namespace is not lightning', () => {
+        const input = {
+            moduleInfo: {
+                name: 'test',
+                namespace: 'c',
+                type: 'bundle',
+                files: filesMap,
+            },
+            srcFileMap: {
+                'test.js': generalMockSourceCode_1.oneGoodMockWithGetterImportUse,
+                'somethingElse.js': 'eval("bye")',
+                'test.css': 'p { text-align: center; }',
+                'test.html': '<html><body><h1>Hey</h1></body></html>',
+            },
+        };
+        const generatorState = initGeneratorState(input);
+        const properties = new Map();
+        properties.set('searchKey', {
+            type: common_shared_1.PropertyTypes.GETTER,
+            usedInPriming: true,
+        });
+        properties.set('perfectlyGood', {
+            type: common_shared_1.PropertyTypes.GETTER,
+            usedInPriming: true,
+        });
+        properties.set('perfectlyGood2', {
+            type: common_shared_1.PropertyTypes.GETTER,
+            usedInPriming: true,
+        });
+        const src = (0, shared_1.getComponentSrcJs)(generatorState);
+        const moduleLevelConsumption = {
+            consumedImports: new Map(),
+        };
+        expect(src).not.toBeUndefined();
+        const ast = (0, common_shared_1.generateAstFromSrcCode)(src);
+        generatorState.scriptGenState.ast = ast;
+        const moduleContext = {
+            astContext: (0, common_shared_1.getAstContextObject)(ast),
+            isExternal: (0, common_shared_1.isExternalModule)(generatorState.input.moduleInfo.namespace),
+        };
+        generatorState.scriptGenState.importMetadata =
+            moduleContext.astContext.importDeclarations;
+        const { getters } = (0, common_shared_1.getPropertyMetadataFromAst)(ast);
+        const res = (0, shared_1.processGetters)(properties, moduleContext, moduleLevelConsumption, getters);
+        expect(res).not.toBeUndefined();
+        expect(res).toHaveLength(1);
+    });
+});
+describe('module generation with getter nodes', () => {
+    it('should mutate ast for any valid getters', () => {
+        const input = initGeneratorInput();
+        // Needed a different Komaci Document for this test. This Komaci Document is generated from k-tester.
+        // Modified the quoting so it can be introduced in code as a JavaScript object
+        input.moduleInfo.files['test.js'] = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, 'general-komaci-docs/two-good-getters/script-komaci-doc.json'), { encoding: 'utf-8' }));
+        input.srcFileMap['test.js'] = generalMockSourceCode_1.oneGoodMockWithGetterImportUse;
+        const generatorState = initGeneratorState(input);
+        // generateCombinedModule() calls transformGetters() for us
+        const combinedModuleAST = (0, modGenScript_1.generateCombinedModule)(generatorState, input.moduleInfo.files['test.js'], input.moduleInfo.files['test.html']);
+        const functionDeclArray = collectModuleLevelFunctionDeclaration(combinedModuleAST);
+        expect(functionDeclArray).toHaveLength(2);
+        // check that getter method `perfectlyGood` was hoisted to top level
+        // functions get generated names. so perfectlyGood should be g0
+        expect(functionDeclArray[0].id?.name).toEqual('g0');
+        const inputParam = functionDeclArray[0].params[0];
+        // check that the `props` parameter was added as input parameter to the newly-hoisted getter method
+        expect(inputParam.name).toEqual('props');
+        expect(functionDeclArray[0].body.body).toHaveLength(2);
+        const variableDeclaration = functionDeclArray[0].body
+            .body[0];
+        const variableDeclarator = variableDeclaration
+            .declarations[0];
+        const optionalMemberExpression1 = variableDeclarator.init;
+        const optionalMemberExpression2 = optionalMemberExpression1.object;
+        const optionalMemberExpression3 = optionalMemberExpression2.object;
+        const ctxMemberExpression = optionalMemberExpression3.object;
+        const identifier = ctxMemberExpression.object;
+        const recordProp = ctxMemberExpression.property;
+        // check that instances of `this.<var>` in the getter where changed to `props.<var>`
+        expect(identifier.name).toEqual('props');
+        expect(recordProp.name).toEqual('record');
+        // check that Import referenced in getter has been converted to local name
+        const returnStmt = functionDeclArray[0].body
+            .body[1];
+        const returnStmtArgument = returnStmt.argument;
+        expect(returnStmtArgument.name).toEqual('i1');
+        // check that getter method `perfectlyGood2` was hoisted to top level
+        // since we process names perfectlyGood2 should map to g1
+        expect(functionDeclArray[1].id?.name).toEqual('g1');
+        // check that Import referenced in getter has been converted to local name
+        const returnStmt2 = functionDeclArray[1].body
+            .body[0];
+        const returnStmtArgument2 = returnStmt2.argument;
+        expect(returnStmtArgument2.name).toEqual('i2');
+    });
+    it('should not mutate ast for empty program', () => {
+        const input = initGeneratorInput();
+        input.moduleInfo.files['test.js'] = {};
+        input.srcFileMap['test.js'] = generalMockSourceCode_1.emptyProgram;
+        const generatorState = initGeneratorState(input);
+        // generateCombinedModule() calls transformGetters() for us
+        const combinedModuleAST = (0, modGenScript_1.generateCombinedModule)(generatorState, input.moduleInfo.files['test.js'], input.moduleInfo.files['test.html']);
+        const body = combinedModuleAST?.program.body;
+        expect(body).not.toBeUndefined();
+        expect(body).toHaveLength(1);
+        expect(body[0].type).toBe('ExportNamedDeclaration');
+    });
+    it('should mutate the komaci document to include getter nodes.', () => {
+        const input = initGeneratorInput();
+        input.moduleInfo.files['test.js'] = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, 'general-komaci-docs/two-good-getters/script-komaci-doc.json'), { encoding: 'utf-8' }));
+        input.srcFileMap['test.js'] = generalMockSourceCode_1.oneGoodMockWithGetterImportUse;
+        const generatorState = initGeneratorState(input);
+        //generateCombinedModule() calls transformGetters() for us
+        (0, modGenScript_1.generateCombinedModule)(generatorState, input.moduleInfo.files['test.js'], input.moduleInfo.files['test.html']);
+        const mutatedKomaciDoc = input.moduleInfo.files['test.js'];
+        expect(mutatedKomaciDoc.adgs).not.toBeUndefined();
+        expect(mutatedKomaciDoc.adgs?.[0].properties).not.toBeUndefined();
+        expect(Object.keys(mutatedKomaciDoc.adgs?.[0].properties)).toHaveLength(6);
+        expect(mutatedKomaciDoc.adgs?.[0].properties?.perfectlyGood.input?.type).toEqual('FunctionReference');
+        expect(mutatedKomaciDoc.adgs?.[0].properties?.perfectlyGood.input?.value).toEqual(2);
+        expect(mutatedKomaciDoc.adgs?.[0].properties?.perfectlyGood2.input?.type).toEqual('FunctionReference');
+        expect(mutatedKomaciDoc.adgs?.[0].properties?.perfectlyGood2.input?.value).toEqual(3);
+        expect(mutatedKomaciDoc.adgs?.[0].functions).not.toBeUndefined();
+        expect(mutatedKomaciDoc.adgs?.[0].functions).toHaveLength(4);
+        expect(mutatedKomaciDoc.adgs?.[0].functions?.[2].type).toEqual('GetterFunction');
+        expect(mutatedKomaciDoc.adgs?.[0].functions?.[2].reference.type).toEqual('InternalReference');
+        expect(mutatedKomaciDoc.adgs?.[0].functions?.[2].reference.value).toEqual('g0');
+        const inputArr = mutatedKomaciDoc.adgs?.[0].functions?.[2]
+            .input?.[0];
+        expect(inputArr.value[0].value).toEqual('record');
+        expect(mutatedKomaciDoc.adgs?.[0].functions?.[3].type).toEqual('GetterFunction');
+        expect(mutatedKomaciDoc.adgs?.[0].functions?.[3].reference.type).toEqual('InternalReference');
+        expect(mutatedKomaciDoc.adgs?.[0].functions?.[3].reference.value).toEqual('g1');
+    });
+    it('should build komaci module with getter nodes', () => {
+        const input = initGeneratorInput();
+        input.moduleInfo.files['test.js'] = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, 'general-komaci-docs/two-good-getters/script-komaci-doc.json'), { encoding: 'utf-8' }));
+        input.srcFileMap['test.js'] = generalMockSourceCode_1.oneGoodMockWithGetterImportUse;
+        const generatorState = initGeneratorState(input);
+        //generateCombinedModule() calls transformGetters() for us
+        const combinedModuleAST = (0, modGenScript_1.generateCombinedModule)(generatorState, input.moduleInfo.files['test.js'], input.moduleInfo.files['test.html']);
+        const resolvableModuleReturn = collectResolutionModuleReturn(combinedModuleAST);
+        const adgArgs = collectAdgFunctionArgs(resolvableModuleReturn);
+        const functionArgs = adgArgs.functions.elements;
+        expect(functionArgs[2].properties).toHaveLength(3);
+        expect(functionArgs[3].properties).toHaveLength(3);
+        expect(functionArgs[2].properties[0].key
+            .name).toEqual('f');
+        expect(functionArgs[2].properties[0].value
+            .name).toEqual('g0');
+        expect(functionArgs[2].properties[1].key
+            .name).toEqual('t');
+        expect(functionArgs[2].properties[1].value
+            .value).toEqual('GetterFunction');
+        expect(functionArgs[2].properties[2].key
+            .name).toEqual('in');
+        expect(functionArgs[2].properties[2]
+            .value.elements).toHaveLength(1);
+        expect(functionArgs[2].properties[2]
+            .value.elements[0].value).toEqual('record');
+    });
+    it('should be able to build a komaci module without colliding with standard internal function names like cg', () => {
+        const baseFilesPath = (0, path_1.join)(__dirname, 'general-komaci-docs/getters-and-compositions-collisions');
+        const input = initGeneratorInput();
+        input.moduleInfo.files['test.js'] = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'script-komaci-doc.json'), {
+            encoding: 'utf-8',
+        }));
+        input.moduleInfo.files['test.html'] = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'html-komaci-doc.json'), {
+            encoding: 'utf-8',
+        }));
+        input.srcFileMap['test.js'] = (0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'source.js'), {
+            encoding: 'utf-8',
+        });
+        input.srcFileMap['test.html'] = (0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'source.html'), { encoding: 'utf-8' });
+        const generatorState = initGeneratorState(input);
+        const combinedModuleAST = (0, modGenScript_1.generateCombinedModule)(generatorState, input.moduleInfo.files['test.js'], input.moduleInfo.files['test.html']);
+        const resolvableModuleReturn = collectResolutionModuleReturn(combinedModuleAST);
+        const adgArgs = collectAdgFunctionArgs(resolvableModuleReturn);
+        const functionArgs = adgArgs.functions.elements;
+        expect(functionArgs[2].properties[0].key
+            .name).toEqual('f');
+        expect(functionArgs[2].properties[0].value
+            .name).toEqual('g0');
+        expect(functionArgs[2].properties[1].key
+            .name).toEqual('t');
+        expect(functionArgs[2].properties[1].value
+            .value).toEqual('GetterFunction');
+        expect(functionArgs[2].properties[2].key
+            .name).toEqual('in');
+        expect(functionArgs[2].properties[2]
+            .value.elements).toHaveLength(0);
+    });
+    it('can effectively process namespaced imports in functions', () => {
+        const baseFilesPath = (0, path_1.join)(__dirname, 'general-komaci-docs/import-types');
+        const input = initGeneratorInput();
+        input.moduleInfo.files['test.js'] = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'script-komaci-doc.json'), {
+            encoding: 'utf-8',
+        }));
+        input.srcFileMap['test.js'] = (0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'source.js'), {
+            encoding: 'utf-8',
+        });
+        const generatorState = initGeneratorState(input);
+        const combinedModuleAST = (0, modGenScript_1.generateCombinedModule)(generatorState, input.moduleInfo.files['test.js'], input.moduleInfo.files['test.html']);
+        expect(combinedModuleAST).not.toBeUndefined();
+        validateFunctions(combinedModuleAST, [
+            {
+                expectedOutput: validationStuff_1.default.functions.functionCallFromNamespacedImport,
+                usedImports: ['Foo'],
+                compiledName: 'g0',
+            },
+            {
+                expectedOutput: validationStuff_1.default.functions.mutlipleCallsFromNamespacedImport,
+                usedImports: ['Foo'],
+                compiledName: 'g1',
+            },
+        ]);
+    });
+    it('can effectively process regular and default imports in functions', () => {
+        const baseFilesPath = (0, path_1.join)(__dirname, 'general-komaci-docs/import-types');
+        const input = initGeneratorInput();
+        input.moduleInfo.files['test.js'] = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'script-komaci-doc.json'), {
+            encoding: 'utf-8',
+        }));
+        input.srcFileMap['test.js'] = (0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'source.js'), {
+            encoding: 'utf-8',
+        });
+        const generatorState = initGeneratorState(input);
+        const combinedModuleAST = (0, modGenScript_1.generateCombinedModule)(generatorState, input.moduleInfo.files['test.js'], input.moduleInfo.files['test.html']);
+        expect(combinedModuleAST).not.toBeUndefined();
+        validateFunctions(combinedModuleAST, [
+            {
+                expectedOutput: validationStuff_1.default.functions.mixedCallsFromImportsWithMultipleImports,
+                usedImports: ['double', 'trouble'],
+                compiledName: 'g2',
+            },
+        ]);
+    });
+    it('can effectively process just default imports in functions', () => {
+        const baseFilesPath = (0, path_1.join)(__dirname, 'general-komaci-docs/import-types');
+        const input = initGeneratorInput();
+        input.moduleInfo.files['test.js'] = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'script-komaci-doc.json'), {
+            encoding: 'utf-8',
+        }));
+        input.srcFileMap['test.js'] = (0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'source.js'), {
+            encoding: 'utf-8',
+        });
+        const generatorState = initGeneratorState(input);
+        const combinedModuleAST = (0, modGenScript_1.generateCombinedModule)(generatorState, input.moduleInfo.files['test.js'], input.moduleInfo.files['test.html']);
+        expect(combinedModuleAST).not.toBeUndefined();
+        validateFunctions(combinedModuleAST, [
+            {
+                expectedOutput: validationStuff_1.default.functions.callFromImportWithOnlySpecificImport,
+                usedImports: ['Bar'],
+                compiledName: 'g3',
+            },
+            {
+                expectedOutput: validationStuff_1.default.functions.callFromDefault,
+                usedImports: ['baz'],
+                compiledName: 'g5',
+            },
+        ]);
+    });
+    it('can effectively process aliased imports in functions', () => {
+        const baseFilesPath = (0, path_1.join)(__dirname, 'general-komaci-docs/import-types');
+        const input = initGeneratorInput();
+        input.moduleInfo.files['test.js'] = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'script-komaci-doc.json'), {
+            encoding: 'utf-8',
+        }));
+        input.srcFileMap['test.js'] = (0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'source.js'), {
+            encoding: 'utf-8',
+        });
+        const generatorState = initGeneratorState(input);
+        const combinedModuleAST = (0, modGenScript_1.generateCombinedModule)(generatorState, input.moduleInfo.files['test.js'], input.moduleInfo.files['test.html']);
+        expect(combinedModuleAST).not.toBeUndefined();
+        validateFunctions(combinedModuleAST, [
+            {
+                expectedOutput: validationStuff_1.default.functions.callFromAlias,
+                usedImports: ['ulteriorMotive'],
+                compiledName: 'g4',
+            },
+        ]);
+    });
+    it('can effectively process a mix of imports in functions', () => {
+        const baseFilesPath = (0, path_1.join)(__dirname, 'general-komaci-docs/import-types');
+        const input = initGeneratorInput();
+        input.moduleInfo.files['test.js'] = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'script-komaci-doc.json'), {
+            encoding: 'utf-8',
+        }));
+        input.srcFileMap['test.js'] = (0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'source.js'), {
+            encoding: 'utf-8',
+        });
+        const generatorState = initGeneratorState(input);
+        const combinedModuleAST = (0, modGenScript_1.generateCombinedModule)(generatorState, input.moduleInfo.files['test.js'], input.moduleInfo.files['test.html']);
+        expect(combinedModuleAST).not.toBeUndefined();
+        validateFunctions(combinedModuleAST, [
+            {
+                expectedOutput: validationStuff_1.default.functions.smorgasbord,
+                usedImports: ['Foo', 'baz', 'trouble', 'double', 'ulteriorMotive'],
+                compiledName: 'g6',
+            },
+        ]);
+    });
+    it('can correctly process properties share same names with imports', () => {
+        const baseFilesPath = (0, path_1.join)(__dirname, 'general-komaci-docs/import-types');
+        const input = initGeneratorInput();
+        input.moduleInfo.files['test.js'] = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'script-komaci-doc.json'), {
+            encoding: 'utf-8',
+        }));
+        input.srcFileMap['test.js'] = (0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'source.js'), {
+            encoding: 'utf-8',
+        });
+        const generatorState = initGeneratorState(input);
+        const combinedModuleAST = (0, modGenScript_1.generateCombinedModule)(generatorState, input.moduleInfo.files['test.js'], input.moduleInfo.files['test.html']);
+        expect(combinedModuleAST).not.toBeUndefined();
+        validateFunctions(combinedModuleAST, [
+            {
+                expectedOutput: validationStuff_1.default.functions.samePropNames,
+                usedImports: [],
+                compiledName: 'g7',
+            },
+        ]);
+    });
+    for (const type of Object.keys(validationStuff_1.default.imports)) {
+        it('can compose a ' + type + ' import as expected', () => {
+            const baseFilesPath = (0, path_1.join)(__dirname, 'general-komaci-docs/import-types');
+            const input = initGeneratorInput();
+            input.moduleInfo.files['test.js'] = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'script-komaci-doc.json'), {
+                encoding: 'utf-8',
+            }));
+            input.srcFileMap['test.js'] = (0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'source.js'), {
+                encoding: 'utf-8',
+            });
+            const generatorState = initGeneratorState(input);
+            const combinedModuleAST = (0, modGenScript_1.generateCombinedModule)(generatorState, input.moduleInfo.files['test.js'], input.moduleInfo.files['test.html']);
+            expect(combinedModuleAST).not.toBeUndefined();
+            validateImport(combinedModuleAST, validationStuff_1.default.imports[type].resourceName, validationStuff_1.default.imports[type].output);
+        });
+    }
+});
+describe('komaciDoc variations', () => {
+    it('handles null exports', () => {
+        const input = initGeneratorInput();
+        input.moduleInfo.files = Object.fromEntries(Object.entries(input.moduleInfo.files).map(([key, val]) => {
+            const { exports = {} } = val;
+            const newExports = Object.fromEntries(Object.entries(exports).map(([key]) => {
+                return [key, null];
+            }));
+            return [key, { ...val, exports: newExports }];
+        }));
+        const generatorState = initGeneratorState(input);
+        const combinedModuleAST = (0, modGenScript_1.generateCombinedModule)(generatorState, input.moduleInfo.files['test.js'], input.moduleInfo.files['test.html']);
+        expect(combinedModuleAST).not.toBeUndefined();
+    });
+});
+describe('processTemplateStrings', () => {
+    it('can process out bad templates and successfully update metadata', () => {
+        const baseFilesPath = (0, path_1.join)(__dirname, 'general-komaci-docs/template-component');
+        const komaciDoc = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'script-komaci-doc.json'), {
+            encoding: 'utf-8',
+        }));
+        const src = (0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'source.js'), {
+            encoding: 'utf-8',
+        });
+        const ast = (0, common_shared_1.generateAstFromSrcCode)(src);
+        const { templateStrings } = (0, common_shared_1.getPropertyMetadataFromAst)(ast);
+        const properties = (0, common_shared_1.collectPropertyMetadataFromScriptDoc)(komaciDoc);
+        const moduleLevelConsumption = {
+            consumedImports: new Map(),
+        };
+        const moduleContext = {
+            astContext: (0, common_shared_1.getAstContextObject)(ast),
+            isExternal: (0, common_shared_1.isExternalModule)('lightning'),
+        };
+        const validTemplates = (0, shared_1.processTemplateStrings)(properties, moduleContext, moduleLevelConsumption, templateStrings);
+        expect(validTemplates).toHaveLength(1);
+        expect(validTemplates[0].generatedName).toBe('t0');
+        expect(validTemplates[0].template.node.key.name).toBe('contractId');
+        expect(validTemplates[0].memberUsage).toHaveLength(1);
+        expect(validTemplates[0].memberUsage).toContain('recordId');
+    });
+});
+//# sourceMappingURL=komaci-ast-unit.spec.js.map

package/build/__tests__/komaci-bundle-module.fixtures.spec.d.ts ADDED Viewed

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