@komaci/esm-generator 240.1.3 → 242.1.0

package/build/__tests__/komaci-bundle-module.fixtures.spec.js

@@ -35,6 +35,7 @@ function generateModuleSource(komaciHTMLDoc, komaciJSDoc, srcFileMap) {
     input.srcFileMap = srcFileMap;
     return (0, index_1.generateKomaciModule)(input);
 }
+// eslint-disable-next-line jest/no-disabled-tests
 describe('fixtures', () => {
     // find all folder paths containing a file whose name ends in ".src"
     const fixtures = glob_1.default.sync(path_1.default.resolve(FIXTURES_DIR, '**/*.src'));

package/build/__tests__/komaci-script-module.fixtures.spec.js

@@ -30,6 +30,7 @@ function generateModuleSource(komaciDoc, actualSrc) {
     }
     return (0, index_1.generateKomaciModule)(input);
 }
+// eslint-disable-next-line jest/no-disabled-tests
 describe('fixtures', () => {
     const fixtures = glob_1.default.sync(path_1.default.resolve(FIXTURES_DIR, '**/*.json'));
     for (const caseEntry of fixtures) {
@@ -48,12 +49,14 @@ describe('fixtures', () => {
             const filePath = fixtureFilePath(fileName);
             fs_1.default.writeFileSync(filePath, content, { encoding: 'utf-8' });
         };
+        // if you need to test a specific case, uncomment out the if
+        // if (caseName === 'class-props') {
         it(`${caseName}`, () => {
             const src = readFixtureFile(INPUT_JSON_FILENAME);
             const komaciDoc = JSON.parse(src);
             const actualModuleSrc = generateModuleSource(komaciDoc, readFixtureFile('actual.js'));
             let expectedModuleSrc = readFixtureFile(EXPECTED_JS_FILENAME);
-            if (expectedModuleSrc === null) {
+            if (expectedModuleSrc === undefined) {
                 // write file if doesn't exist (ie new fixture)
                 expectedModuleSrc = actualModuleSrc;
                 writeFixtureFile(EXPECTED_JS_FILENAME, expectedModuleSrc);
@@ -61,6 +64,7 @@ describe('fixtures', () => {
             // check that the actual newly generated mod source matches expected
             expect(actualModuleSrc).toEqual(expectedModuleSrc);
         });
+        // }
     }
 });
 //# sourceMappingURL=komaci-script-module.fixtures.spec.js.map

package/build/__tests__/komaci-template-module.fixtures.spec.js

@@ -22,7 +22,8 @@ function generateModuleSource(komaciDoc) {
     };
     return (0, index_1.generateKomaciModule)(input);
 }
-describe('fixtures', () => {
+// eslint-disable-next-line jest/no-disabled-tests
+describe('template only fixtures', () => {
     const fixtures = glob_1.default.sync(path_1.default.resolve(FIXTURES_DIR, '**/*.json'));
     for (const caseEntry of fixtures) {
         const caseFolder = path_1.default.dirname(caseEntry);

package/build/componentAstProcessing.d.ts

@@ -0,0 +1,34 @@
+import * as t from '@babel/types';
+import { GeneratorInput } from './types';
+import { NodePath } from '@babel/core';
+import { ModuleContext, ModuleMetadata } from '@komaci/common-shared';
+/**
+ * Retrieve the file path for the js of a component
+ * @param generatorState GeneratorState containg the GeneratorInput, which in turn contains the JS raw source file
+ * @returns Returns raw source code as string for the js of a component if it exists in the srcFileMap
+ *          Returns undefined if no JS source file (whose filename also matches the LWC module name) was included in the
+ *          GeneratorState.GeneratorInput by lwc-platform, other calling code.
+ */
+export declare function getComponentSrcJs(generatorInput: GeneratorInput): string | undefined;
+/**
+ * AST is traversed to see if they contain getter functions that are not valid. For each getter that is valid, we will
+ * update contextual information about the class and pass back info about the valid getters.
+ *
+ * @param {ClassPropertyContexts} properties the Map of properties metadata, which tells whether a property is used by a wire functions
+ * @param {ModuleContext} moduleContext Contextual info about the module itself
+ * @param {ModuleLevelConsumption} moduleLevelConsumption Details about how things are consuming module level entities. NOTE: This is updated in here for import usage
+ * @param {t.File} ast The ast for the module
+ * @returns Information about valid getters to be added to the resolvable Module.
+ */
+export declare function processGetters(adgIndex: number, moduleContext: ModuleContext, moduleMetadata: ModuleMetadata, getterMethodPaths: NodePath<t.ClassMethod>[]): void;
+/**
+ * Validate what templates are good and then uplift the metadata about how they interact with other portions of the modules.
+ * i.e. import, property references, used in priming
+ * @param {ClassPropertyContexts} properties the Map of properties metadata, which tells whether a property is used by a wire functions
+ * @param {ModuleContext} moduleContext Contextual info about the module itself
+ * @param {ModuleLevelConsumption} moduleLevelConsumption Details about how things are consuming module level entities. NOTE: This is updated in here for import usage
+ * @param {Array<NodePath<t.ClassProperty>>} templateStrings The templates to validate
+ * @returns Information about valid templates to be added to the resolvable Module.
+ */
+export declare function processTemplateStrings(adgIndex: number, moduleContext: ModuleContext, moduleMetadata: ModuleMetadata, templateStrings: Array<NodePath<t.ClassProperty>>): void;
+//# sourceMappingURL=componentAstProcessing.d.ts.map

package/build/componentAstProcessing.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTemplateStrings = exports.processGetters = exports.getComponentSrcJs = void 0;
+const static_analyzer_1 = require("@komaci/static-analyzer");
+const common_shared_1 = require("@komaci/common-shared");
+/**
+ * Retrieve the file path for the js of a component
+ * @param generatorState GeneratorState containg the GeneratorInput, which in turn contains the JS raw source file
+ * @returns Returns raw source code as string for the js of a component if it exists in the srcFileMap
+ *          Returns undefined if no JS source file (whose filename also matches the LWC module name) was included in the
+ *          GeneratorState.GeneratorInput by lwc-platform, other calling code.
+ */
+function getComponentSrcJs(generatorInput) {
+    let sourceCode;
+    const moduleName = generatorInput.moduleInfo.name;
+    if (generatorInput.srcFileMap) {
+        const filename = Object.keys(generatorInput.srcFileMap).find((filename) => filename.endsWith('.js') && filename.startsWith(moduleName));
+        if (filename) {
+            sourceCode = generatorInput.srcFileMap[filename];
+        }
+    }
+    return sourceCode;
+}
+exports.getComponentSrcJs = getComponentSrcJs;
+/**
+ * AST is traversed to see if they contain getter functions that are not valid. For each getter that is valid, we will
+ * update contextual information about the class and pass back info about the valid getters.
+ *
+ * @param {ClassPropertyContexts} properties the Map of properties metadata, which tells whether a property is used by a wire functions
+ * @param {ModuleContext} moduleContext Contextual info about the module itself
+ * @param {ModuleLevelConsumption} moduleLevelConsumption Details about how things are consuming module level entities. NOTE: This is updated in here for import usage
+ * @param {t.File} ast The ast for the module
+ * @returns Information about valid getters to be added to the resolvable Module.
+ */
+function processGetters(adgIndex, moduleContext, moduleMetadata, getterMethodPaths) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const adg = moduleMetadata.adgs.get(adgIndex);
+    getterMethodPaths
+        // map changes the item at each index to be an instance of ValidGetterContext
+        .forEach((getter, index) => {
+        const isGetterValid = (0, static_analyzer_1.validateGetter)(getter, adgIndex, moduleMetadata, moduleContext, false);
+        const getterName = (0, common_shared_1.getClassMethodName)(getter);
+        if (isGetterValid) {
+            const { identifiers } = (0, common_shared_1.implicitConsumptionMetadata)(getter, adgIndex, moduleMetadata);
+            const property = adg.properties.get(getterName);
+            if (property) {
+                property.type = common_shared_1.PropertyTypes.GETTER;
+                const functionMeta = {
+                    type: common_shared_1.FunctionTypes.GETTER_FUNCTION,
+                    componentAstNode: getter,
+                    requiredProperties: identifiers,
+                    generatedName: `g${index}`,
+                };
+                const functionIndex = adg.functions.push(functionMeta) - 1;
+                property.functionIndex = functionIndex;
+                property.inital = undefined;
+            }
+            (0, common_shared_1.updatePropertyUsage)(getterName, identifiers, adg.properties, common_shared_1.PropertyTypes.GETTER);
+        }
+        else {
+            const property = adg.properties.get(getterName);
+            if (property) {
+                property.type = common_shared_1.PropertyTypes.GETTER;
+                property.functionIndex = common_shared_1.UNSUPPORTED_FUNCTION;
+            }
+        }
+    });
+}
+exports.processGetters = processGetters;
+/**
+ * Validate what templates are good and then uplift the metadata about how they interact with other portions of the modules.
+ * i.e. import, property references, used in priming
+ * @param {ClassPropertyContexts} properties the Map of properties metadata, which tells whether a property is used by a wire functions
+ * @param {ModuleContext} moduleContext Contextual info about the module itself
+ * @param {ModuleLevelConsumption} moduleLevelConsumption Details about how things are consuming module level entities. NOTE: This is updated in here for import usage
+ * @param {Array<NodePath<t.ClassProperty>>} templateStrings The templates to validate
+ * @returns Information about valid templates to be added to the resolvable Module.
+ */
+function processTemplateStrings(adgIndex, moduleContext, moduleMetadata, templateStrings) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const adg = moduleMetadata.adgs.get(adgIndex);
+    return templateStrings.forEach((template, index) => {
+        const isTemplateValid = (0, static_analyzer_1.validateTemplateString)(template, adgIndex, moduleMetadata, moduleContext, false);
+        const name = (0, common_shared_1.getFromIdentifierOrStringLiteral)(template.node.key);
+        const property = adg.properties.get(name);
+        if (isTemplateValid) {
+            const { identifiers } = (0, common_shared_1.implicitConsumptionMetadata)(template, adgIndex, moduleMetadata);
+            if (property) {
+                property.type = common_shared_1.PropertyTypes.TEMPLATE_STRING;
+                const functionMeta = {
+                    type: common_shared_1.FunctionTypes.TEMPLATE_STRING,
+                    componentAstNode: template,
+                    requiredProperties: identifiers,
+                    generatedName: `t${index}`,
+                };
+                const functionIndex = adg.functions.push(functionMeta) - 1;
+                property.functionIndex = functionIndex;
+                property.inital = undefined;
+            }
+            (0, common_shared_1.updatePropertyUsage)(name, identifiers, adg.properties, common_shared_1.PropertyTypes.TEMPLATE_STRING);
+        }
+    });
+}
+exports.processTemplateStrings = processTemplateStrings;
+//# sourceMappingURL=componentAstProcessing.js.map

package/build/compositionAstGeneration.d.ts

@@ -0,0 +1,76 @@
+import { Composition, Container, ComposedAdg, Iteration, Slot, Image } from '@komaci/types';
+import { ModuleMetadata } from '@komaci/common-shared';
+import * as t from '@babel/types';
+/**
+ * Convert an array of Komaci Compositions into a babel array of expressions.
+ * This is used for both the top-level compositions in the Komaci Doc, as well
+ * as their nested child compositions.
+ * @param {ModuleMetadata} moduleMetadata collected module metadata about this given component
+ * @param {Composition[]} compositions an array of Compositions from a Template JS
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {ArrayExpression | undefined} an ArrayExpression representing the passed in Composition array, or undefined
+ * if no compositions were passed in
+ */
+export declare function compositionsToArrayExpression(moduleMetadata: ModuleMetadata, compositions?: Composition[], iterationContext?: string[]): t.ArrayExpression | undefined;
+/**
+ * Convert any of the Komaci composition types into a babel expression, to be included in the generated module.
+ * NOTE: For instances where a composition has an isActive coditional, the module will be using the u function provided by the fct factory object to
+ * to check for an unresolved value. This function can be overridden, otherwise the default implementaitno will be used. https://salesforce.quip.com/XY4WAbfaLR5E
+ * @param {ModuleMetadata} moduleMetadata collected module metadata about this given component
+ * @param {Composition} composition the Composition to covert
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {Expression | ArrayExpression} the babel expression (Expression | ArrayExpression) to which the Composition was converted
+ */
+export declare function compositionToExpression(moduleMetadata: ModuleMetadata, composition: Composition, iterationContext?: string[]): t.Expression | t.ArrayExpression;
+/**
+ * Converts a Komaci container into a babel expression. If the container doesn't
+ * impact data flow, then an ArrayExpression is returned for its children.
+ * @param {ModuleMetadata} moduleMetadata collected module metadata about this given component
+ * @param {Container} container the Komaci container (i.e. <div> tag)
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {Expression | ArrayExpression} The babel Expression or ArrayExpression converted from the input Container
+ */
+export declare function containerToExpression(moduleMetadata: ModuleMetadata, container: Container, iterationContext?: string[]): t.Expression | t.ArrayExpression;
+/**
+ * Converts a Komaci ComposedAdg (which references an Import) into a call to the Resolver API for a composed graph, `cg`.
+ * @param {ModuleMetadata} moduleMetadata collected module metadata about this given component
+ * @param {ComposedAdg} composedAdg the ComposedAdg whose input.type is an `ImportReference`
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {Expression} a babel Expression representing the composed graph (cg) resolver API call. Throws an Error if the
+ * composedAdg.input.type is not equal to 'ImportReference'
+ */
+export declare function composedAdgToExpression(moduleMetadata: ModuleMetadata, composedAdg: ComposedAdg, iterationContext?: string[]): t.Expression;
+/**
+ * Converts a Komaci Iteration into a call to Resolver API for an iteration, i.e `i`.
+ * @param {ModuleMetadata} moduleMetadata collected module metadata about this given component
+ * @param {Iteration} iteration the Iteration from a template file
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {Expression} the babel Expression that represents the call into the Resolver API for an iteration
+ */
+export declare function iterationToExpression(moduleMetadata: ModuleMetadata, iteration: Iteration, iterationContext?: string[]): t.Expression;
+/**
+ * Convert Komaci slot into call to Resolver API for a slot, `s`
+ * @param {ModuleMetadata} moduleMetadata collected module metadata about this given component
+ * @param {Slot} slot The Slot to be converted into an expression
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {Expression} the babel Expression representing the Slot call into the Resolver API
+ */
+export declare function slotToExpression(moduleMetadata: ModuleMetadata, slot: Slot, iterationContext?: string[]): t.Expression;
+/**
+ * Converts Komaci Image into prompt for the Resolver API to make an image priming call
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Image} image the Image node from the KomaciDocument
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {Expression} the babel Expression representing the Image prompt into the Resolver API
+ */
+export declare function imageToExpression(image: Image, iterationContext?: string[]): t.Expression;
+/**
+ * Creates a babel configuration ObjectExpression for provided composition. This is the `CompositionConfig`
+ * from Resolver API in its babel ObjectExpression form.
+ * @param {ComposedAdg | Container | Slot} composition the Composition from which to create a configuration (as a ComposedAdg, Container, or Slot)
+ * @param {string} componentId the component indentifier, as a string
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {ObjectExpression} the babel ObjectExpression representing the Resolver API CompositionConfig
+ */
+export declare function getCompositionConfig(composition: ComposedAdg | Container | Slot, componentId?: string, iterationContext?: string[]): t.ObjectExpression;
+//# sourceMappingURL=compositionAstGeneration.d.ts.map

package/build/compositionAstGeneration.js

@@ -0,0 +1,299 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompositionConfig = exports.imageToExpression = exports.slotToExpression = exports.iterationToExpression = exports.composedAdgToExpression = exports.containerToExpression = exports.compositionToExpression = exports.compositionsToArrayExpression = void 0;
+const common_shared_1 = require("@komaci/common-shared");
+const t = __importStar(require("@babel/types"));
+const genericAstGeneration_1 = require("./genericAstGeneration");
+const types_1 = require("./types");
+/**
+ * Convert an array of Komaci Compositions into a babel array of expressions.
+ * This is used for both the top-level compositions in the Komaci Doc, as well
+ * as their nested child compositions.
+ * @param {ModuleMetadata} moduleMetadata collected module metadata about this given component
+ * @param {Composition[]} compositions an array of Compositions from a Template JS
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {ArrayExpression | undefined} an ArrayExpression representing the passed in Composition array, or undefined
+ * if no compositions were passed in
+ */
+function compositionsToArrayExpression(moduleMetadata, compositions, iterationContext) {
+    if (!compositions) {
+        return undefined;
+    }
+    const elements = [];
+    compositions.forEach((composition) => {
+        const expr = compositionToExpression(moduleMetadata, composition, iterationContext);
+        if (expr) {
+            if (t.isArrayExpression(expr)) {
+                // Special case, such as the top-most container, where the container has
+                // no impact on resolution process. In which case we want to flatten
+                // the array to effectively remove the container from the generated mod.
+                expr.elements.forEach((element) => {
+                    if (t.isExpression(element)) {
+                        elements.push(element);
+                    }
+                });
+            }
+            else {
+                elements.push(expr);
+            }
+        }
+    });
+    return t.arrayExpression(elements);
+}
+exports.compositionsToArrayExpression = compositionsToArrayExpression;
+/**
+ * Convert any of the Komaci composition types into a babel expression, to be included in the generated module.
+ * NOTE: For instances where a composition has an isActive coditional, the module will be using the u function provided by the fct factory object to
+ * to check for an unresolved value. This function can be overridden, otherwise the default implementaitno will be used. https://salesforce.quip.com/XY4WAbfaLR5E
+ * @param {ModuleMetadata} moduleMetadata collected module metadata about this given component
+ * @param {Composition} composition the Composition to covert
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {Expression | ArrayExpression} the babel expression (Expression | ArrayExpression) to which the Composition was converted
+ */
+function compositionToExpression(moduleMetadata, composition, iterationContext) {
+    let expression;
+    // Get the expression specific to each type of composition.
+    switch (composition.type) {
+        case 'Container':
+            expression = containerToExpression(moduleMetadata, composition, iterationContext);
+            break;
+        case 'ComposedAdg':
+            expression = composedAdgToExpression(moduleMetadata, composition, iterationContext);
+            break;
+        case 'Iteration':
+            expression = iterationToExpression(moduleMetadata, composition, iterationContext);
+            break;
+        case 'Slot':
+            expression = slotToExpression(moduleMetadata, composition, iterationContext);
+            break;
+        case 'Image':
+            expression = imageToExpression(composition, iterationContext);
+            break;
+    }
+    // If the composition has an isActive condition, then
+    // expression needs to be proceded by a conditional check.
+    if (composition.isActive) {
+        let conditionalTest = (0, genericAstGeneration_1.bindingToExpression)(composition.isActive.input, iterationContext);
+        if (composition.isActive.negate) {
+            conditionalTest = t.unaryExpression('!', conditionalTest);
+        }
+        const prop = (0, genericAstGeneration_1.bindingToExpression)(composition.isActive.input, iterationContext, true);
+        const unresolvedTest = t.callExpression(types_1.ID.UNRESOLVED_FUNC, [prop]);
+        const test = t.logicalExpression('||', unresolvedTest, conditionalTest);
+        expression = t.conditionalExpression(test, expression, types_1.ID.UNDEFINED);
+    }
+    return expression;
+}
+exports.compositionToExpression = compositionToExpression;
+/**
+ * Converts a Komaci container into a babel expression. If the container doesn't
+ * impact data flow, then an ArrayExpression is returned for its children.
+ * @param {ModuleMetadata} moduleMetadata collected module metadata about this given component
+ * @param {Container} container the Komaci container (i.e. <div> tag)
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {Expression | ArrayExpression} The babel Expression or ArrayExpression converted from the input Container
+ */
+function containerToExpression(moduleMetadata, container, iterationContext) {
+    const children = compositionsToArrayExpression(moduleMetadata, container.compositions, iterationContext) || t.arrayExpression([]);
+    // If key or slot is specified, then the container will need to be
+    // accounted for in the module via the element function.
+    if (container.key || container.slot) {
+        const params = [];
+        // arg1: Composition configuration.
+        params.push(getCompositionConfig(container, undefined, iterationContext));
+        // arg2: Context.
+        params.push(types_1.ID.CONTEXT);
+        // arg3: Array of expressions for each child.
+        params.push(children);
+        return t.callExpression(types_1.ID.ELEMENT_FUNC, params);
+    }
+    else {
+        // No key or slot, so only need to include it's children
+        // in the generated mod.
+        return children.elements.length === 1
+            ? children.elements[0]
+            : children;
+    }
+}
+exports.containerToExpression = containerToExpression;
+/**
+ * Converts a Komaci ComposedAdg (which references an Import) into a call to the Resolver API for a composed graph, `cg`.
+ * @param {ModuleMetadata} moduleMetadata collected module metadata about this given component
+ * @param {ComposedAdg} composedAdg the ComposedAdg whose input.type is an `ImportReference`
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {Expression} a babel Expression representing the composed graph (cg) resolver API call. Throws an Error if the
+ * composedAdg.input.type is not equal to 'ImportReference'
+ */
+function composedAdgToExpression(moduleMetadata, composedAdg, iterationContext) {
+    let componentId;
+    const params = [];
+    // arg1: Input source to the composed graph function.
+    if (composedAdg.input.type === 'ImportReference') {
+        const importName = moduleMetadata.importIndexReference.get('t-' + composedAdg.input.value);
+        const importInfo = importName
+            ? moduleMetadata.importsByName.get(importName)
+            : undefined;
+        if (importInfo) {
+            componentId = importInfo.componentId;
+            params.push(t.identifier(importInfo.generatorAlias));
+        }
+    }
+    else {
+        // Schema supports this, but downstream logic (e.g. analysis) doesn't (yet).
+        throw new Error(common_shared_1.ERROR_PREFIX + 'binding not yet supported for ComposedAdg input');
+    }
+    // arg2: Composition configuration.
+    params.push(getCompositionConfig(composedAdg, componentId, iterationContext));
+    // arg3: Context.
+    params.push(types_1.ID.CONTEXT);
+    // arg4: Array of expressions for each child.
+    const children = compositionsToArrayExpression(moduleMetadata, composedAdg.compositions, iterationContext);
+    if (children && children.elements.length) {
+        params.push(children);
+    }
+    return t.callExpression(types_1.ID.COMPOSED_GRAPH_FUNC, params);
+}
+exports.composedAdgToExpression = composedAdgToExpression;
+/**
+ * Converts a Komaci Iteration into a call to Resolver API for an iteration, i.e `i`.
+ * @param {ModuleMetadata} moduleMetadata collected module metadata about this given component
+ * @param {Iteration} iteration the Iteration from a template file
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {Expression} the babel Expression that represents the call into the Resolver API for an iteration
+ */
+function iterationToExpression(moduleMetadata, iteration, iterationContext = []) {
+    const params = [];
+    // arg1: Expression for the collection being iterated.
+    params.push((0, genericAstGeneration_1.bindingToExpression)(iteration.input, iterationContext));
+    // arg2: Context.
+    params.push(types_1.ID.CONTEXT);
+    // arg3: Function to return compositions inside the the iteration.
+    // Use context to understand which iterations contain the code being analyzed.
+    iterationContext.unshift(iteration.iterator);
+    const children = compositionsToArrayExpression(moduleMetadata, iteration.compositions, iterationContext) || t.arrayExpression([]);
+    iterationContext.shift();
+    // interation.iterator contains string variables like "i", "j", "k", or loop control
+    // variables must prepend user variable prefix "user_var_" to the variable when used
+    // in arrow function declaration, to prevent resolution issues
+    params.push(t.arrowFunctionExpression([t.identifier(types_1.USER_VARIABLE_PREFIX + iteration.iterator)], t.blockStatement([t.returnStatement(children)])));
+    return t.callExpression(types_1.ID.ITERATION_FUNC, params);
+}
+exports.iterationToExpression = iterationToExpression;
+/**
+ * Convert Komaci slot into call to Resolver API for a slot, `s`
+ * @param {ModuleMetadata} moduleMetadata collected module metadata about this given component
+ * @param {Slot} slot The Slot to be converted into an expression
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {Expression} the babel Expression representing the Slot call into the Resolver API
+ */
+function slotToExpression(moduleMetadata, slot, iterationContext) {
+    const params = [];
+    // arg1: Slot Name.
+    params.push(t.stringLiteral(slot.name));
+    // arg2: Composition configuration.
+    params.push(getCompositionConfig(slot, undefined, iterationContext));
+    // arg3: Context.
+    params.push(types_1.ID.CONTEXT);
+    // arg4: Array of expressions for each child.
+    const defaultContent = compositionsToArrayExpression(moduleMetadata, slot.compositions, iterationContext);
+    if (defaultContent && defaultContent.elements.length) {
+        params.push(defaultContent);
+    }
+    return t.callExpression(types_1.ID.SLOT_FUNC, params);
+}
+exports.slotToExpression = slotToExpression;
+/**
+ * Converts Komaci Image into prompt for the Resolver API to make an image priming call
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Image} image the Image node from the KomaciDocument
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {Expression} the babel Expression representing the Image prompt into the Resolver API
+ */
+function imageToExpression(image, iterationContext) {
+    const params = [];
+    const funcObjProps = [];
+    if ((0, common_shared_1.isCompositionAnImage)(image)) {
+        if ((0, common_shared_1.isSrcPrimitiveValue)(image.src)) {
+            // type guard ensures `image.src` is a PrimitiveValue
+            // lwc-platform will NOT produce an Image KomaciNode with a blank or missing src attribute.
+            // However, just in case we do encounter this, we handle it here by simply NOT producing the
+            // function ObjectProperty for such a node.
+            if (image.src.value &&
+                typeof image.src.value === 'string' &&
+                image.src.value !== '') {
+                funcObjProps.push(t.objectProperty(types_1.ID.IMG_SRC, t.stringLiteral(image.src.value)));
+            }
+        }
+        else if ((0, common_shared_1.isSrcABinding)(image.src)) {
+            // type guard ensures `image.src` is a Binding
+            // lwc-platform will NOT produce an Image KomaciNode with a blank or missing src attribute.
+            // However, just in case we do encounter this, we handle it here by simply NOT producing the
+            // function ObjectProperty for such a node.
+            if (image.src.value !== '') {
+                funcObjProps.push(t.objectProperty(types_1.ID.IMG_SRC, (0, genericAstGeneration_1.bindingToExpression)(image.src, iterationContext)));
+            }
+        }
+    }
+    params.push(t.objectExpression(funcObjProps));
+    return t.callExpression(types_1.ID.IMG_FUNC, params);
+}
+exports.imageToExpression = imageToExpression;
+/**
+ * Creates a babel configuration ObjectExpression for provided composition. This is the `CompositionConfig`
+ * from Resolver API in its babel ObjectExpression form.
+ * @param {ComposedAdg | Container | Slot} composition the Composition from which to create a configuration (as a ComposedAdg, Container, or Slot)
+ * @param {string} componentId the component indentifier, as a string
+ * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @returns {ObjectExpression} the babel ObjectExpression representing the Resolver API CompositionConfig
+ */
+function getCompositionConfig(composition, componentId, iterationContext) {
+    const config = [];
+    if (composition.slot) {
+        config.push(t.objectProperty(types_1.ID.SLOT, t.stringLiteral(composition.slot)));
+    }
+    // ComposedAdg config contains additional information.
+    if (composition.type === 'ComposedAdg') {
+        if (componentId) {
+            config.push(t.objectProperty(types_1.ID.COMPONENT_ID, t.stringLiteral(componentId)));
+        }
+        if (composition.properties) {
+            const props = [];
+            for (const propName of Object.keys(composition.properties)) {
+                const prop = composition.properties[propName];
+                if (prop.type === 'Binding') {
+                    props.push(t.objectProperty(t.identifier(propName), (0, genericAstGeneration_1.bindingToExpression)(prop, iterationContext)));
+                }
+                else if (prop.type === 'PrimitiveValue') {
+                    props.push(t.objectProperty(t.identifier(propName), (0, genericAstGeneration_1.primitiveToExpression)(prop)));
+                }
+            }
+            config.push(t.objectProperty(types_1.ID.PROPS, t.objectExpression(props)));
+        }
+    }
+    return t.objectExpression(config);
+}
+exports.getCompositionConfig = getCompositionConfig;
+//# sourceMappingURL=compositionAstGeneration.js.map

package/build/functionAstGeneration.d.ts

@@ -0,0 +1,81 @@
+import { NodePath } from '@babel/core';
+import * as t from '@babel/types';
+import { AdgMetadata, HoistedFunctionMetadata, IdKeys, ImportMetadata, ModuleMetadata } from '@komaci/common-shared';
+import { Composition } from '@komaci/types';
+/**
+ * Take a local function (getter, template string, etc) and prepare it for the resolvable module
+ * - sanitize the function
+ * - give the function a module level signature with generated name
+ *
+ * @param functionMetadata Metadata about the function to hoist
+ * @param importMetadata Map of all the import metadata we know about
+ *
+ * @returns a composed module level function or undefined if we don't have the
+ *          information for composing the funciton
+ */
+export declare function hoistLocalFunction(functionMetadata: HoistedFunctionMetadata, importMetadata: Map<string, ImportMetadata>): t.FunctionDeclaration | undefined;
+/**
+ * Take a function defined on a class and sanitize it's interactions in preparation to be hoisted into resolvable module/
+ *
+ * Two main things happen during sanitization:
+ * - references to imports are updated to their generated name (i.e. i2)
+ * - references to `this` are replaced with references to `props`
+ *
+ * @param nodePath The node to sanitize
+ * @param importMetadata Metadata about all the imports we know about
+ */
+export declare function sanitizeFunction(nodePath: NodePath<t.ClassProperty | t.ClassMethod>, importMetadata: Map<string, ImportMetadata>): void;
+/**
+ * Converts a Komaci ADG into a CallExpression to the ADG factory function
+ * call for the Resolver API.
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Adg} adg the current ADG to convert into an Expression
+ * @returns {t.Expression} Babel Expression representation of the adg() factory function call
+ */
+export declare function adgToExpression(adg: AdgMetadata, moduleMetadata: ModuleMetadata): t.CallExpression;
+/**
+ * Return the variable declaration done via destructuring the factory object
+ * (e.g. const { i, cg } = fct;) or undefined if no fct functions are used.
+ * @param factoryFuncs Set of strings that represent used factory functions
+ * @returns composed ast statement for factory functions
+ */
+export declare function getFactoryFuncDeclaration(factoryFuncs: Set<IdKeys>): t.VariableDeclaration | undefined;
+/**
+ * composes ast statements for a given set of ADG Metadata
+ *
+ * @param adg the metadata for the adg we want to compose an ast for
+ * @param moduleMetadata Metadata about the entire module
+ * @returns the declaration for a given adg
+ */
+export declare function composeAdgFunction(adg: AdgMetadata, moduleMetadata: ModuleMetadata): t.ExportNamedDeclaration | t.ExportDefaultDeclaration | t.FunctionDeclaration;
+/**
+ * associate composed adgs with their exported names
+ * @param adgName the name of the adg
+ * @param exportName the name it will be exported as
+ * @returns the composed export statement
+ */
+export declare function addExportStatement(adgName: string, exportName: string): t.ExportNamedDeclaration | t.ExportDefaultDeclaration;
+/**
+ * Compose the function that calls the `adg` function with all of it's needful info
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Adg} adg The current ADG for which to compose the babel statements
+ * @returns the babel statements to represent the function
+ */
+export declare function getAdgFunctionBody(adg: AdgMetadata, moduleMetadata: ModuleMetadata): t.BlockStatement;
+/**
+ * Converts array of template Compositions into a representation that is an inline function
+ * @param {GeneratorState} generatorState the current state of esm-generator
+ * @param {Composition[]} compositions array of Compositions to convert
+ * @returns {t.ArrowFunctionExpression} an inline ArrowFunctionExpression representing the input Compositions
+ */
+export declare function getInlineFunctionFromTemplateCompositions(moduleMetadata: ModuleMetadata, requiredFactoryFunctions: Set<IdKeys>, compositions: Composition[]): t.ArrowFunctionExpression;
+/**
+ * A barebones resolvable module default export with a singular node describing the context of an error.
+ *
+ * We return this instead of a real resolvable module if something throws an error during resolvable module generation
+ * @param generatorState The state of the generator for pass through to adgToExpression
+ * @param error The error that was thrown
+ * @returns A default export representing the error state for this resolvable module
+ */
+export declare function produceErrorAdgFunction(moduleMetadata: ModuleMetadata, error: Error): t.Program;
+//# sourceMappingURL=functionAstGeneration.d.ts.map