@komaci/esm-generator 240.1.5 → 242.1.1

package/build/__tests__/genericAstGeneration.spec.js

@@ -0,0 +1,877 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generator_1 = __importDefault(require("@babel/generator"));
+const common_shared_1 = require("@komaci/common-shared");
+const genericAstGeneration_1 = require("../genericAstGeneration");
+const t = __importStar(require("@babel/types"));
+describe('valueToExpression', () => {
+    it('composes proper statement for complex object. Includes ObjectValue, ArrayValue, PropertyReference, and Primitive Value', () => {
+        const wireFunctionObject = {
+            type: 'ObjectValue',
+            value: {
+                fields: {
+                    type: 'ArrayValue',
+                    value: [
+                        { type: 'PrimitiveValue', value: 'Account.Id' },
+                        { type: 'PrimitiveValue', value: 'Account.Name' },
+                        { type: 'PrimitiveValue', value: 'Account.CreatedById' },
+                        { type: 'PrimitiveValue', value: 'Account.CreatedDate' },
+                        { type: 'PrimitiveValue', value: 'Account.OwnerId' },
+                        { type: 'PrimitiveValue', value: 'Account.ParentId' },
+                    ],
+                },
+                recordId: { type: 'PropertyReference', value: 'recordId' },
+            },
+        };
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        const result = (0, genericAstGeneration_1.valueToExpression)(wireFunctionObject, moduleMetadata);
+        expect(result).not.toBeUndefined();
+        expect(result.properties).toHaveLength(2);
+        const objExprProperties = result.properties;
+        expect(objExprProperties[0].key.value).toEqual('fields');
+        expect(objExprProperties[0].value.elements).toHaveLength(6);
+        expect(objExprProperties[0].value
+            .elements[0].value).toEqual('Account.Id');
+        expect(objExprProperties[0].value
+            .elements[1].value).toEqual('Account.Name');
+        expect(objExprProperties[0].value
+            .elements[2].value).toEqual('Account.CreatedById');
+        expect(objExprProperties[0].value
+            .elements[3].value).toEqual('Account.CreatedDate');
+        expect(objExprProperties[0].value
+            .elements[4].value).toEqual('Account.OwnerId');
+        expect(objExprProperties[0].value
+            .elements[5].value).toEqual('Account.ParentId');
+        expect(objExprProperties[1].key.value).toEqual('recordId');
+        expect(objExprProperties[1].value
+            .property.name).toEqual('recordId');
+    });
+    it('composes proper statement when komaci value is an importReference', () => {
+        const komaciValue = {
+            type: 'ImportReference',
+            value: '0/names/0',
+            namespacedMember: 'p1',
+        };
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        const komaciDoc = {
+            imports: [
+                { resourceName: 'force/shared', names: ['*'] },
+                { resourceName: 'laf/transformWire', names: ['*'] },
+                { resourceName: 'lightning/uiRecordApi', names: ['getRecord'] },
+            ],
+        };
+        (0, common_shared_1.initializeImportMetdataFromKomaciDocument)(komaciDoc, moduleMetadata);
+        const result = (0, genericAstGeneration_1.valueToExpression)(komaciValue, moduleMetadata);
+        expect(result).not.toBeUndefined();
+        expect(result.object.name).toEqual('i0');
+        expect(result.property.name).toEqual('p1');
+    });
+    it('composes proper statement when komaci value is an unsupported importReference', () => {
+        const komaciValue = {
+            type: 'ImportReference',
+            value: '0/names/0',
+            namespacedMember: 'p1',
+        };
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        const komaciDoc = {
+            imports: [
+                { resourceName: 'unsuported/shared', names: ['*'] },
+                { resourceName: 'laf/transformWire', names: ['*'] },
+                { resourceName: 'lightning/uiRecordApi', names: ['getRecord'] },
+            ],
+        };
+        (0, common_shared_1.initializeImportMetdataFromKomaciDocument)(komaciDoc, moduleMetadata);
+        const result = (0, genericAstGeneration_1.valueToExpression)(komaciValue, moduleMetadata);
+        expect(result).not.toBeUndefined();
+        expect(result.type).toBe('Identifier');
+        expect(result.name).toBe('unresolved');
+    });
+    it('marks invalid import reference as unresolved', () => {
+        const komaciValue = {
+            type: 'ImportReference',
+            value: '7/names/0',
+            namespacedMember: 'p1',
+        };
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        const komaciDoc = {
+            imports: [
+                { resourceName: 'unsuported/shared', names: ['*'] },
+                { resourceName: 'laf/transformWire', names: ['*'] },
+                { resourceName: 'lightning/uiRecordApi', names: ['getRecord'] },
+            ],
+        };
+        (0, common_shared_1.initializeImportMetdataFromKomaciDocument)(komaciDoc, moduleMetadata);
+        const result = (0, genericAstGeneration_1.valueToExpression)(komaciValue, moduleMetadata);
+        expect(result).not.toBeUndefined();
+        expect(result.type).toBe('Identifier');
+        expect(result.name).toBe('unresolved');
+    });
+});
+describe('functionToExpression', () => {
+    it('composes proper object expression for a valid getter function', () => {
+        //need to make a hoistedGetterFunction object
+        // module metadata based on komaci document.
+        const functionMeta = {
+            type: common_shared_1.FunctionTypes.GETTER_FUNCTION,
+            componentAstNode: undefined,
+            requiredProperties: ['tempProp'],
+            generatedName: `g${0}`,
+        };
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        const result = (0, genericAstGeneration_1.functionToExpression)(moduleMetadata, functionMeta);
+        expect(result).not.toBeUndefined();
+        expect(result?.type).toEqual('ObjectExpression');
+        expect(result?.properties).toHaveLength(3);
+        const properties = result?.properties;
+        expect(properties[0].key.name).toEqual('f');
+        expect(properties[0].value.name).toEqual('g0');
+        expect(properties[1].key.name).toEqual('t');
+        expect(properties[1].value.value).toEqual('GetterFunction');
+        expect(properties[2].key.name).toEqual('in');
+        expect(properties[2].value.elements).toHaveLength(1);
+    });
+    it('composes proper object expression for a valid template string', () => {
+        //need to make a hoistedGetterFunction object
+        // module metadata based on komaci document.
+        const functionMeta = {
+            type: common_shared_1.FunctionTypes.TEMPLATE_STRING,
+            componentAstNode: undefined,
+            requiredProperties: ['tempProp'],
+            generatedName: `t${0}`,
+        };
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        const result = (0, genericAstGeneration_1.functionToExpression)(moduleMetadata, functionMeta);
+        expect(result).not.toBeUndefined();
+        expect(result?.type).toEqual('ObjectExpression');
+        expect(result?.properties).toHaveLength(3);
+        const properties = result?.properties;
+        expect(properties[0].key.name).toEqual('f');
+        expect(properties[0].value.name).toEqual('t0');
+        expect(properties[1].key.name).toEqual('t');
+        expect(properties[1].value.value).toEqual('TemplatedStringFunction');
+        expect(properties[2].key.name).toEqual('in');
+        expect(properties[2].value.elements).toHaveLength(1);
+    });
+});
+describe('propertyToExpression', () => {
+    it('composes proper object expression when input is property with inital value', () => {
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        const propertyConext = {
+            type: common_shared_1.PropertyTypes.BASE,
+            inital: { type: 'PrimitiveValue', value: 5 },
+            usedInPriming: false,
+            isPublic: true,
+        };
+        const result = (0, genericAstGeneration_1.propertyToExpression)(moduleMetadata, propertyConext);
+        expect(result).not.toBeUndefined();
+        expect(result?.type).toEqual('ObjectExpression');
+        expect(result?.properties).toHaveLength(2);
+        const properties = result?.properties;
+        expect(properties).toHaveLength(2);
+        expect(properties[0].key.name).toEqual('a');
+        expect(properties[0].value.value).toBeTruthy();
+        expect(properties[1].key.name).toEqual('i');
+        expect(properties[1].value.value).toEqual(5);
+    });
+    it('composes proper object expression when property is a getter', () => {
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        const propertyConext = {
+            type: common_shared_1.PropertyTypes.GETTER,
+            usedInPriming: false,
+            functionIndex: 0,
+            isPublic: false,
+        };
+        const result = (0, genericAstGeneration_1.propertyToExpression)(moduleMetadata, propertyConext);
+        expect(result).not.toBeUndefined();
+        expect(result?.type).toEqual('ObjectExpression');
+        expect(result?.properties).toHaveLength(2);
+        const properties = result?.properties;
+        expect(properties).toHaveLength(2);
+        expect(properties[0].key.name).toEqual('a');
+        expect(properties[0].value.value).toBeFalsy();
+        expect(properties[1].key.name).toEqual('f');
+        expect(properties[1].value.value).toEqual(0);
+    });
+    it('composes proper object expression when property is a Template string', () => {
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        const propertyConext = {
+            type: common_shared_1.PropertyTypes.TEMPLATE_STRING,
+            usedInPriming: false,
+            functionIndex: 0,
+            isPublic: false,
+        };
+        const result = (0, genericAstGeneration_1.propertyToExpression)(moduleMetadata, propertyConext);
+        expect(result).not.toBeUndefined();
+        expect(result?.type).toEqual('ObjectExpression');
+        expect(result?.properties).toHaveLength(2);
+        const properties = result?.properties;
+        expect(properties).toHaveLength(2);
+        expect(properties[0].key.name).toEqual('a');
+        expect(properties[0].value.value).toBeFalsy();
+        expect(properties[1].key.name).toEqual('f');
+        expect(properties[1].value.value).toEqual(0);
+    });
+    it('composes proper object expression when property is a wire', () => {
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        const propertyConext = {
+            type: common_shared_1.PropertyTypes.WIRE,
+            usedInPriming: false,
+            functionIndex: 1,
+            isPublic: false,
+        };
+        const result = (0, genericAstGeneration_1.propertyToExpression)(moduleMetadata, propertyConext);
+        expect(result).not.toBeUndefined();
+        expect(result?.type).toEqual('ObjectExpression');
+        expect(result?.properties).toHaveLength(2);
+        const properties = result?.properties;
+        expect(properties).toHaveLength(2);
+        expect(properties[0].key.name).toEqual('a');
+        expect(properties[0].value.value).toBeFalsy();
+        expect(properties[1].key.name).toEqual('f');
+        expect(properties[1].value.value).toEqual(1);
+    });
+    it('composes proper object expression when property is a wire that is unresolvabe', () => {
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        const propertyConext = {
+            type: common_shared_1.PropertyTypes.WIRE,
+            usedInPriming: false,
+            functionIndex: common_shared_1.UNSUPPORTED_FUNCTION,
+            isPublic: false,
+        };
+        const result = (0, genericAstGeneration_1.propertyToExpression)(moduleMetadata, propertyConext);
+        expect(result).not.toBeUndefined();
+        expect(result?.type).toEqual('ObjectExpression');
+        expect(result?.properties).toHaveLength(2);
+        const properties = result?.properties;
+        expect(properties).toHaveLength(2);
+        expect(properties[0].key.name).toEqual('a');
+        expect(properties[0].value.value).toBeFalsy();
+        expect(properties[1].key.name).toEqual('g');
+        expect(properties[1].value.value).toEqual(undefined);
+    });
+});
+describe('processWireFunctionType', () => {
+    const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+    (0, common_shared_1.composeImportMetadata)('randomWire', 'laf/transformWire', true, '0/names/0', moduleMetadata);
+    (0, common_shared_1.composeImportMetadata)('apexWire', '@salesforce/apex/recordApi', true, '1/names/0', moduleMetadata);
+    (0, common_shared_1.composeImportMetadata)('getRecord', 'lightning/uiRecordApi', true, '2/names/0', moduleMetadata);
+    (0, common_shared_1.composeImportMetadata)('bacth_getRecord', 'lightning/uiRecordApi', true, '2/names/1', moduleMetadata);
+    (0, common_shared_1.composeImportMetadata)('reducer', 'lightning/uiRecordApi', true, '2/names/2', moduleMetadata);
+    (0, common_shared_1.composeImportMetadata)('CurrentPageReference', 'laf/transformWire', true, '3/names/0', moduleMetadata);
+    it('throws an error when a function that isnt a wire is passed in', () => {
+        const throwingFunc = () => (0, genericAstGeneration_1.processWireFunctionType)({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            type: common_shared_1.FunctionTypes.GETTER_FUNCTION,
+            requiredProperties: [],
+            importReference: { functionName: '' },
+        }, moduleMetadata);
+        expect(throwingFunc).toThrow();
+    });
+    it('does nothing when function refers to a non existent import', () => {
+        const astStatements = (0, genericAstGeneration_1.processWireFunctionType)({
+            type: common_shared_1.FunctionTypes.WIRE_FUNCTION,
+            requiredProperties: [],
+            importReference: { functionName: 'test' },
+        }, moduleMetadata);
+        expect(astStatements).toBeUndefined();
+    });
+    it('effectively builds metadata for a non priming adapter wire', () => {
+        const astStatements = (0, genericAstGeneration_1.processWireFunctionType)({
+            type: common_shared_1.FunctionTypes.WIRE_FUNCTION,
+            requiredProperties: [],
+            input: [
+                {
+                    type: 'ObjectValue',
+                    value: {
+                        fields: {
+                            type: 'ArrayValue',
+                            value: [
+                                {
+                                    type: 'PrimitiveValue',
+                                    value: 'Account.Name',
+                                },
+                            ],
+                        },
+                        resourceId: {
+                            type: 'PropertyReference',
+                            value: 'recordId',
+                        },
+                        recordType: {
+                            type: 'PropertyReference',
+                            value: 'recordType',
+                        },
+                    },
+                },
+            ],
+            importReference: { functionName: 'randomWire' },
+        }, moduleMetadata);
+        expect(astStatements).not.toBeUndefined();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const { code } = (0, generator_1.default)(t.objectExpression(astStatements));
+        expect(code).toBe(`{
+  f: i0,
+  fN: "randomWire",
+  t: "WireFunction",
+  c: ctx => ({
+    "fields": ["Account.Name"],
+    "resourceId": ctx.props.recordId,
+    "recordType": ctx.props.recordType
+  }),
+  in: ["recordId", "recordType"]
+}`);
+    });
+    it('effectively builds metadata for an apex wire', () => {
+        const astStatements = (0, genericAstGeneration_1.processWireFunctionType)({
+            type: common_shared_1.FunctionTypes.WIRE_FUNCTION,
+            requiredProperties: [],
+            importReference: { functionName: 'apexWire' },
+        }, moduleMetadata);
+        expect(astStatements).not.toBeUndefined();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const { code } = (0, generator_1.default)(t.objectExpression(astStatements));
+        expect(code).toBe(`{
+  f: i1,
+  fN: "recordApi",
+  t: "WireFunction",
+  wt: "apex",
+  c: ctx => ({})
+}`);
+    });
+    it('effectively builds metadata for a context wire', () => {
+        const astStatements = (0, genericAstGeneration_1.processWireFunctionType)({
+            type: common_shared_1.FunctionTypes.WIRE_FUNCTION,
+            requiredProperties: [],
+            importReference: { functionName: 'CurrentPageReference' },
+        }, moduleMetadata);
+        expect(astStatements).not.toBeUndefined();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const { code } = (0, generator_1.default)(t.objectExpression(astStatements));
+        expect(code).toBe(`{
+  f: i5,
+  fN: "CurrentPageReference",
+  t: "WireFunction",
+  wt: "cpr",
+  c: ctx => ({})
+}`);
+    });
+    it('effectively builds metadata for a priming adapter wire with neither a batcher or reducer', () => {
+        const astStatements = (0, genericAstGeneration_1.processWireFunctionType)({
+            type: common_shared_1.FunctionTypes.PRIMING_FUNCTION,
+            requiredProperties: [],
+            importReference: { functionName: 'getRecord' },
+        }, moduleMetadata);
+        expect(astStatements).not.toBeUndefined();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const { code } = (0, generator_1.default)(t.objectExpression(astStatements));
+        expect(code).toBe(`{
+  f: i2,
+  fN: "getRecord",
+  t: "PrimingFunction",
+  c: ctx => ({})
+}`);
+    });
+    it('effectively builds metadata for a priming adapter wire without a reducer', () => {
+        const astStatements = (0, genericAstGeneration_1.processWireFunctionType)({
+            type: common_shared_1.FunctionTypes.PRIMING_FUNCTION,
+            requiredProperties: [],
+            importReference: {
+                functionName: 'getRecord',
+                batchingName: 'bacth_getRecord',
+            },
+        }, moduleMetadata);
+        expect(astStatements).not.toBeUndefined();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const { code } = (0, generator_1.default)(t.objectExpression(astStatements));
+        expect(code).toBe(`{
+  f: i2,
+  fN: "getRecord",
+  b: i3,
+  bN: "bacth_getRecord",
+  t: "PrimingFunction",
+  c: ctx => ({})
+}`);
+    });
+    it('effectively builds metadata for a priming adapter wire', () => {
+        const astStatements = (0, genericAstGeneration_1.processWireFunctionType)({
+            type: common_shared_1.FunctionTypes.PRIMING_FUNCTION,
+            requiredProperties: [],
+            importReference: {
+                functionName: 'getRecord',
+                batchingName: 'bacth_getRecord',
+                reducer: 'reducer',
+            },
+        }, moduleMetadata);
+        expect(astStatements).not.toBeUndefined();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const { code } = (0, generator_1.default)(t.objectExpression(astStatements));
+        expect(code).toBe(`{
+  f: i2,
+  fN: "getRecord",
+  b: i3,
+  bN: "bacth_getRecord",
+  r: i4,
+  t: "PrimingFunction",
+  c: ctx => ({})
+}`);
+    });
+});
+describe('processErrorFunction', () => {
+    const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+    it('should compose ast nodes properly for error function', () => {
+        const res = (0, genericAstGeneration_1.processErrorFunction)({
+            type: common_shared_1.FunctionTypes.ERROR,
+            input: [
+                {
+                    type: 'ObjectValue',
+                    value: {
+                        error: {
+                            type: 'PrimitiveValue',
+                            value: common_shared_1.ERROR_PREFIX +
+                                'Something that is not an error was thrown',
+                        },
+                    },
+                },
+            ],
+        }, moduleMetadata);
+        expect(res).not.toBeUndefined();
+        const { code } = (0, generator_1.default)(t.objectExpression(res));
+        expect(code).toBe(`{
+  t: "ErrorFunction",
+  c: {
+    "error": "[komaci] Something that is not an error was thrown"
+  }
+}`);
+    });
+});
+describe('addImportStatements', () => {
+    const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+    (0, common_shared_1.composeImportMetadata)('default', 'lightning/uiTestingApi', true, '0/names/0', moduleMetadata, 'test');
+    (0, common_shared_1.composeImportMetadata)('regularImport', 'lightning/uiTestingApi', true, '0/names/1', moduleMetadata);
+    (0, common_shared_1.composeImportMetadata)('tes1', 'badImport', false, '1/names/0', moduleMetadata);
+    (0, common_shared_1.composeImportMetadata)('tes2', 'badImport', false, '1/names/1', moduleMetadata);
+    (0, common_shared_1.composeImportMetadata)('*', '@salesforce/labels', true, '2/names/0', moduleMetadata, 'labels');
+    (0, common_shared_1.composeImportMetadata)('tes3', 'lightning/uiRecordApi', true, '3/names/0', moduleMetadata);
+    (0, common_shared_1.composeImportMetadata)('tes4', 'lightning/uiRecordApi', true, '3/names/1', moduleMetadata, 'changed');
+    (0, common_shared_1.composeImportMetadata)('tes5', 'lightning/uiRecordApi', true, '3/names/2', moduleMetadata);
+    (0, common_shared_1.composeImportMetadata)('adg', '@salesforce/komaci/c__foo__foo.js', true, '4/names/0', moduleMetadata);
+    moduleMetadata.importsByNamespace.set('lightning/uiTestingApi', {
+        names: new Set(['default', 'regularImport']),
+        isDefaultSpecifier: true,
+        isSupported: true,
+        isNamespaceSpecifier: false,
+        resourceName: 'lightning/uiTestingApi',
+    });
+    moduleMetadata.importsByNamespace.set('badImport', {
+        names: new Set(['tes1', 'tes2']),
+        isDefaultSpecifier: false,
+        isSupported: false,
+        isNamespaceSpecifier: false,
+        resourceName: 'badImport',
+    });
+    moduleMetadata.importsByNamespace.set('@salesforce/labels', {
+        names: new Set(['*']),
+        isDefaultSpecifier: false,
+        isSupported: true,
+        isNamespaceSpecifier: true,
+        resourceName: '@salesforce/labels',
+    });
+    moduleMetadata.importsByNamespace.set('lightning/uiRecordApi', {
+        names: new Set(['tes3', 'tes4', 'tes5']),
+        isDefaultSpecifier: false,
+        isSupported: true,
+        isNamespaceSpecifier: false,
+        resourceName: 'lightning/uiRecordApi',
+    });
+    moduleMetadata.importsByNamespace.set('@salesforce/komaci/c__foo__foo.js', {
+        names: new Set(['adg']),
+        isDefaultSpecifier: false,
+        isSupported: true,
+        isNamespaceSpecifier: false,
+        resourceName: '@salesforce/komaci/c__foo__foo.js',
+    });
+    // lazy way to say almost all are used in priming
+    for (const importMetadata of moduleMetadata.importsByName.values()) {
+        importMetadata.usedInPriming =
+            importMetadata.name !== 'tes5' && importMetadata.name !== 'tes2';
+    }
+    const findImportDeclaration = (statements, resourceName) => statements.find((statement) => statement.source.value === resourceName);
+    const validateForEachList = (statements, cb) => statements.forEach(cb);
+    const scriptModuleOnlyStatements = [];
+    const combinedModuleStatements = [];
+    (0, genericAstGeneration_1.addImportStatements)(moduleMetadata, scriptModuleOnlyStatements, {
+        calledFromGenerateCombinedModule: false,
+    });
+    (0, genericAstGeneration_1.addImportStatements)(moduleMetadata, combinedModuleStatements, {
+        calledFromGenerateCombinedModule: true,
+    });
+    it('can compose an import with a default and a normal import together', () => {
+        validateForEachList([scriptModuleOnlyStatements, combinedModuleStatements], (statements) => {
+            const importStatement = findImportDeclaration(statements, 'lightning/uiTestingApi');
+            expect(importStatement).not.toBeUndefined();
+            expect(importStatement.specifiers).toHaveLength(2);
+            expect(importStatement.specifiers[0].type).toBe('ImportDefaultSpecifier');
+            expect(importStatement
+                .specifiers[0].local.name).toBe(moduleMetadata.importsByName.get('test')?.generatorAlias);
+            expect(importStatement.specifiers[1].type).toBe('ImportSpecifier');
+            expect(importStatement
+                .specifiers[1].local.name).toBe(moduleMetadata.importsByName.get('regularImport')?.generatorAlias);
+            expect(importStatement
+                .specifiers[1].imported.name).toBe('regularImport');
+        });
+    });
+    it('will not compose a bad import', () => {
+        validateForEachList([scriptModuleOnlyStatements, combinedModuleStatements], (statements) => {
+            const importStatement = findImportDeclaration(statements, 'badImport');
+            expect(importStatement).toBeUndefined();
+        });
+    });
+    it('can compose an import with a namespace import', () => {
+        validateForEachList([scriptModuleOnlyStatements, combinedModuleStatements], (statements) => {
+            const importStatement = findImportDeclaration(statements, '@salesforce/labels');
+            expect(importStatement).not.toBeUndefined();
+            expect(importStatement.specifiers).toHaveLength(1);
+            expect(importStatement.specifiers[0].type).toBe('ImportNamespaceSpecifier');
+            expect(importStatement
+                .specifiers[0].local.name).toBe(moduleMetadata.importsByName.get('labels')?.generatorAlias);
+        });
+    });
+    it('will leave out an import not used in priming from the composed specifiers', () => {
+        validateForEachList([scriptModuleOnlyStatements, combinedModuleStatements], (statements) => {
+            const importStatement = findImportDeclaration(statements, 'lightning/uiRecordApi');
+            expect(importStatement).not.toBeUndefined();
+            expect(importStatement.specifiers).toHaveLength(2);
+            expect(importStatement.specifiers[0].type).toBe('ImportSpecifier');
+            expect(importStatement
+                .specifiers[0].imported.name).toBe('tes3');
+            expect(importStatement.specifiers[1].type).toBe('ImportSpecifier');
+            expect(importStatement
+                .specifiers[1].local.name).toBe(moduleMetadata.importsByName.get('changed')?.generatorAlias);
+            expect(importStatement
+                .specifiers[1].imported.name).toBe('tes4');
+        });
+    });
+    it('will lop the last portion of a @salesforce/komaci import off if its a combined module only', () => {
+        const scriptImport = findImportDeclaration(scriptModuleOnlyStatements, '@salesforce/komaci/c__foo__foo.js');
+        expect(scriptImport).not.toBeUndefined();
+        const combinedImport = findImportDeclaration(combinedModuleStatements, '@salesforce/komaci/c__foo');
+        expect(combinedImport).not.toBeUndefined();
+    });
+});
+describe('collectMetadataForNonDefaultTemplates', () => {
+    const templateMap = {};
+    beforeEach(() => {
+        // fixture-template-files/component-refernece
+        templateMap['component-reference'] = {
+            compositions: [
+                {
+                    type: 'Container',
+                    compositions: [
+                        {
+                            type: 'ComposedAdg',
+                            input: {
+                                type: 'ImportReference',
+                                value: '0/names/0',
+                            },
+                            properties: {},
+                        },
+                        {
+                            type: 'ComposedAdg',
+                            input: {
+                                type: 'ImportReference',
+                                value: '0/names/0',
+                            },
+                            properties: {
+                                attribute1: {
+                                    type: 'PrimitiveValue',
+                                    value: 'literalString1',
+                                },
+                                attribute2: {
+                                    type: 'PrimitiveValue',
+                                    value: 'lteralString2',
+                                },
+                            },
+                        },
+                        {
+                            type: 'ComposedAdg',
+                            input: {
+                                type: 'ImportReference',
+                                value: '0/names/0',
+                            },
+                            properties: {
+                                attribute1: {
+                                    type: 'Binding',
+                                    value: 'record',
+                                },
+                                attribute2: {
+                                    type: 'Binding',
+                                    value: 'recordId',
+                                },
+                                attribute3: {
+                                    type: 'Binding',
+                                    value: 'record/data/Name',
+                                },
+                            },
+                        },
+                        {
+                            type: 'ComposedAdg',
+                            input: {
+                                type: 'ImportReference',
+                                value: '0/names/0',
+                            },
+                            properties: {
+                                attribute1: {
+                                    type: 'PrimitiveValue',
+                                    value: 'literalString1',
+                                },
+                                attribute2: {
+                                    type: 'Binding',
+                                    value: 'recordId',
+                                },
+                                attribute3: {
+                                    type: 'PrimitiveValue',
+                                    value: true,
+                                },
+                            },
+                        },
+                        {
+                            type: 'ComposedAdg',
+                            input: {
+                                type: 'ImportReference',
+                                value: '0/names/0',
+                            },
+                            properties: {
+                                attributeUpperCase: {
+                                    type: 'PrimitiveValue',
+                                    value: 'convert kebab to camel',
+                                },
+                            },
+                        },
+                        {
+                            type: 'ComposedAdg',
+                            input: {
+                                type: 'ImportReference',
+                                value: '0/names/0',
+                            },
+                            properties: {
+                                StartsWithUpperCase: {
+                                    type: 'PrimitiveValue',
+                                    value: 'should be StartsWithUpperCase',
+                                },
+                            },
+                        },
+                        {
+                            type: 'ComposedAdg',
+                            input: {
+                                type: 'ImportReference',
+                                value: '1/names/0',
+                            },
+                            properties: {},
+                        },
+                        {
+                            type: 'ComposedAdg',
+                            input: {
+                                type: 'ImportReference',
+                                value: '2/names/0',
+                            },
+                            properties: {
+                                label: {
+                                    type: 'PrimitiveValue',
+                                    value: 'Base',
+                                },
+                                title: {
+                                    type: 'PrimitiveValue',
+                                    value: 'Looks like a link',
+                                },
+                                variant: {
+                                    type: 'PrimitiveValue',
+                                    value: 'base',
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+            imports: [
+                {
+                    resourceName: '@salesforce/komaci/c__child1__child1.js',
+                    names: ['default'],
+                },
+                {
+                    resourceName: '@salesforce/komaci/c__upperCaseInName__upperCaseInName.js',
+                    names: ['default'],
+                },
+                {
+                    resourceName: '@salesforce/komaci/lightning__button__button.js',
+                    names: ['default'],
+                },
+            ],
+            exports: {
+                default: {
+                    type: 'CompositionReference',
+                    value: 0,
+                },
+            },
+        };
+        //fixture-template-files/conditional-simple
+        templateMap['conditional-simple'] = {
+            compositions: [
+                {
+                    type: 'Container',
+                    compositions: [
+                        {
+                            type: 'Container',
+                            isActive: {
+                                input: {
+                                    type: 'Binding',
+                                    value: 'someCondition',
+                                },
+                                negate: false,
+                            },
+                            compositions: [
+                                {
+                                    type: 'ComposedAdg',
+                                    input: {
+                                        type: 'ImportReference',
+                                        value: '0/names/0',
+                                    },
+                                    properties: {},
+                                },
+                                {
+                                    type: 'ComposedAdg',
+                                    input: {
+                                        type: 'ImportReference',
+                                        value: '1/names/0',
+                                    },
+                                    properties: {},
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+            exports: {
+                default: {
+                    type: 'CompositionReference',
+                    value: 0,
+                },
+            },
+            imports: [
+                {
+                    resourceName: '@salesforce/komaci/c__child1__child1.js',
+                    names: ['default'],
+                },
+                {
+                    resourceName: '@salesforce/komaci/c__child2__child2.js',
+                    names: ['default'],
+                },
+            ],
+        };
+    });
+    it('collects metadata info for non default templates', () => {
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        moduleMetadata.templateKomaciDocMap = templateMap;
+        moduleMetadata.adgGeneratorIndex = 1;
+        const defaultAdg = (0, common_shared_1.initAdgMetadataObject)('adg0');
+        moduleMetadata.adgs.set(0, defaultAdg);
+        const templateImport = {
+            name: 'default',
+            komaciDocImportRef: '0/names/0',
+            importAlias: 'child1',
+            generatorAlias: 'i0',
+            resourceName: './conditional-simple',
+            staticallyAnalyzable: true,
+            templateKomaciDoc: templateMap['conditional-simple'],
+            usedInPriming: true,
+            isFromInternalNamespace: true,
+            isFromSupportedLibrary: true,
+        };
+        moduleMetadata.importsByName.set('child1', templateImport);
+        //assuming that component-reference is the default.
+        (0, genericAstGeneration_1.collectMetadataForNonDefaultTemplates)(moduleMetadata, 'component-reference');
+        expect(moduleMetadata.adgGeneratorIndex).toBe(2);
+        expect(moduleMetadata.importGeneratorIndex).toBe(2);
+        expect(moduleMetadata.importIndexReference.get('t1-0/names/0')).not.toBeUndefined();
+        expect(moduleMetadata.importIndexReference.get('t1-1/names/0')).not.toBeUndefined();
+    });
+    it('collects metadata info for non default templates, multiple non default templates', () => {
+        templateMap['default-template'] = {};
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        moduleMetadata.templateKomaciDocMap = templateMap;
+        moduleMetadata.adgGeneratorIndex = 1;
+        const defaultAdg = (0, common_shared_1.initAdgMetadataObject)('adg0');
+        moduleMetadata.adgs.set(0, defaultAdg);
+        const templateImport = {
+            name: 'default',
+            komaciDocImportRef: '0/names/0',
+            importAlias: 'child1',
+            generatorAlias: 'i0',
+            resourceName: './component-reference',
+            staticallyAnalyzable: true,
+            templateKomaciDoc: templateMap['component-reference'],
+            usedInPriming: true,
+            isFromInternalNamespace: true,
+            isFromSupportedLibrary: true,
+        };
+        moduleMetadata.importsByName.set('child1', templateImport);
+        const templateImport2 = {
+            name: 'default',
+            komaciDocImportRef: '1/names/0',
+            importAlias: 'child2',
+            generatorAlias: 'i1',
+            resourceName: './conditional-simple',
+            staticallyAnalyzable: true,
+            templateKomaciDoc: templateMap['conditional-simple'],
+            usedInPriming: true,
+            isFromInternalNamespace: true,
+            isFromSupportedLibrary: true,
+        };
+        moduleMetadata.importsByName.set('child2', templateImport2);
+        //assuming that component-reference is the default.
+        (0, genericAstGeneration_1.collectMetadataForNonDefaultTemplates)(moduleMetadata, 'default-template');
+        expect(moduleMetadata.adgGeneratorIndex).toBe(3);
+        expect(moduleMetadata.importGeneratorIndex).toBe(5);
+        expect(moduleMetadata.importIndexReference.get('t1-0/names/0')).not.toBeUndefined();
+        expect(moduleMetadata.importIndexReference.get('t1-1/names/0')).not.toBeUndefined();
+        expect(moduleMetadata.importIndexReference.get('t1-2/names/0')).not.toBeUndefined();
+        expect(moduleMetadata.importIndexReference.get('t2-0/names/0')).not.toBeUndefined();
+        expect(moduleMetadata.importIndexReference.get('t2-1/names/0')).not.toBeUndefined();
+    });
+    it('no changes when only looking at the default', () => {
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        moduleMetadata.templateKomaciDocMap = templateMap;
+        moduleMetadata.adgGeneratorIndex = 1;
+        const defaultAdg = (0, common_shared_1.initAdgMetadataObject)('adg0');
+        moduleMetadata.adgs.set(0, defaultAdg);
+        //assuming that component-reference is the default.
+        (0, genericAstGeneration_1.collectMetadataForNonDefaultTemplates)(moduleMetadata, 'component-reference');
+        expect(moduleMetadata.adgGeneratorIndex).toBe(1);
+        expect(moduleMetadata.importGeneratorIndex).toBe(0);
+    });
+});
+//# sourceMappingURL=genericAstGeneration.spec.js.map