@komaci/esm-generator 240.1.3 → 242.1.0

package/build/genericAstGeneration.js

@@ -0,0 +1,600 @@
+"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.exportNamedDeclarationForDynamicImport = exports.addUndefinedDefaultExport = exports.propertyToExpression = exports.functionToExpression = exports.bindingToExpression = exports.primitiveToExpression = exports.valueToExpression = exports.processWireFunctionType = exports.processErrorFunction = exports.addImportStatements = exports.generateResolvableModule = void 0;
+const common_shared_1 = require("@komaci/common-shared");
+const static_analyzer_1 = require("@komaci/static-analyzer");
+const t = __importStar(require("@babel/types"));
+const compositionAstGeneration_1 = require("./compositionAstGeneration");
+const componentAstProcessing_1 = require("./componentAstProcessing");
+const types_1 = require("./types");
+const functionAstGeneration_1 = require("./functionAstGeneration");
+const CONTEXT_MAPPING = {
+    cpr: 'CurrentPageReference',
+};
+/**
+ * Compose a resolvable module for a component. There are three types of outputted resolvable modules
+ * - A resolvable module built from a component with ONLY a template
+ * - A resolvable module built from a component with ONLY a js file
+ * - A resolvable module that has both a template a js file
+ *
+ * Currently we only support JS and template files that match the names of components
+ *
+ * @param input Generator input
+ * @param scriptKomaciDoc The js komaci doc if it exists
+ * @param templateKomaciDoc The tempalte komaci doc if it exists
+ * @param source string pointing to the source of the script doc if it exists
+ * @returns The babel AST for the generated resolvable module
+ */
+function generateResolvableModule(input, scriptKomaciDoc, templateKomaciDoc, source) {
+    const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+    let componentDefaultAdgIndex;
+    const hasScriptKomaciDoc = scriptKomaciDoc && Object.keys(scriptKomaciDoc).length !== 0;
+    const hasTemplateKomaciDoc = templateKomaciDoc && Object.keys(templateKomaciDoc).length !== 0;
+    const combinedModule = scriptKomaciDoc !== undefined && templateKomaciDoc !== undefined;
+    const isBundle = input.moduleInfo.type === 'bundle';
+    // start of metadata collection
+    if (scriptKomaciDoc) {
+        (0, common_shared_1.initializeImportMetdataFromKomaciDocument)(scriptKomaciDoc, moduleMetadata);
+        let ast;
+        if (source) {
+            ast = (0, common_shared_1.generateAstFromSrcCode)(source);
+            (0, common_shared_1.collectImportMetadataFromAst)(ast, moduleMetadata);
+        }
+        componentDefaultAdgIndex = scriptKomaciDoc.exports?.default?.value;
+        scriptKomaciDoc.adgs?.forEach((_, index) => (0, common_shared_1.initalizeAdgMetadata)(index, scriptKomaciDoc, moduleMetadata, componentDefaultAdgIndex === index && ast !== undefined, isBundle));
+        (0, common_shared_1.mapExportNamesToAdgs)(scriptKomaciDoc.exports, moduleMetadata);
+        if (ast && componentDefaultAdgIndex !== undefined) {
+            const { getters, templateStrings } = (0, common_shared_1.getPropertyMetadataFromAst)(ast);
+            const moduleContext = {
+                astContext: (0, common_shared_1.getAstContextObject)(ast),
+                isExternal: (0, common_shared_1.isExternalModule)(input.moduleInfo.namespace),
+            };
+            (0, componentAstProcessing_1.processGetters)(componentDefaultAdgIndex, moduleContext, moduleMetadata, getters);
+            (0, componentAstProcessing_1.processTemplateStrings)(componentDefaultAdgIndex, moduleContext, moduleMetadata, templateStrings);
+        }
+    }
+    if (hasTemplateKomaciDoc) {
+        componentDefaultAdgIndex = (0, common_shared_1.reconcileDefaultAdg)(componentDefaultAdgIndex, moduleMetadata);
+        (0, common_shared_1.initializeImportMetdataFromKomaciDocument)(templateKomaciDoc, moduleMetadata, true);
+        (0, common_shared_1.addTemplateUsageForDefaultAdg)(templateKomaciDoc, componentDefaultAdgIndex, moduleMetadata);
+        if (isBundle && !hasScriptKomaciDoc) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            (0, common_shared_1.upliftFakePropsFromTemplate)(moduleMetadata.adgs.get(componentDefaultAdgIndex));
+        }
+    }
+    // for script only docs we assume there there is still a html file around so we build the import to reference that html
+    if (!isBundle && hasScriptKomaciDoc && !hasTemplateKomaciDoc) {
+        const newImport = (0, common_shared_1.composeImportMetadata)('default', `@salesforce/komaci/${input.moduleInfo.namespace}__${input.moduleInfo.name}__${input.moduleInfo.name}.html`, true, common_shared_1.NO_KOMACI_DOC_REF, moduleMetadata, common_shared_1.IdKeys.DEFAULT_COMP);
+        newImport.usedInPriming = true;
+        newImport.isFromSupportedLibrary = true;
+        newImport.generatorAlias = 'comp1';
+    }
+    // all metadata collected at this point, time to start building ast
+    const statements = [];
+    const program = t.program(statements);
+    const file = t.file(program);
+    addImportStatements(moduleMetadata, statements, {
+        calledFromGenerateCombinedModule: combinedModule,
+    });
+    // template only resolvable modules are composed completely differently (for now)
+    if (!combinedModule && hasTemplateKomaciDoc) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const adg = moduleMetadata.adgs.get(componentDefaultAdgIndex);
+        const compositionsArray = (0, compositionAstGeneration_1.compositionsToArrayExpression)(moduleMetadata, templateKomaciDoc.compositions) || t.arrayExpression([]);
+        // Create default export of the main template function.
+        // e.g. `export default function (fct, ctx) {...}`
+        const params = [types_1.ID.FACTORY, types_1.ID.CONTEXT];
+        const compositionFunction = [];
+        const body = t.blockStatement(compositionFunction);
+        // Destructuring of factory functions.
+        const fctFuncs = (0, functionAstGeneration_1.getFactoryFuncDeclaration)(adg.requiredCompositionFactoryFunctions);
+        if (fctFuncs) {
+            compositionFunction.push(fctFuncs);
+        }
+        // Return the array of composition expressions.
+        compositionFunction.push(t.returnStatement(compositionsArray));
+        statements.push(t.exportDefaultDeclaration(t.functionDeclaration(null, params, body)));
+    }
+    else {
+        // uplift local functions from default exported adg
+        if (componentDefaultAdgIndex !== undefined) {
+            const defaultAdg = moduleMetadata.adgs.get(componentDefaultAdgIndex);
+            defaultAdg?.functions.forEach((func) => {
+                if (func.type === common_shared_1.FunctionTypes.GETTER_FUNCTION ||
+                    func.type === common_shared_1.FunctionTypes.TEMPLATE_STRING) {
+                    const hoistedFunction = (0, functionAstGeneration_1.hoistLocalFunction)(func, moduleMetadata.importsByName);
+                    if (hoistedFunction) {
+                        statements.push(hoistedFunction);
+                    }
+                }
+            });
+        }
+        else {
+            statements.push(addUndefinedDefaultExport());
+        }
+        for (const adg of moduleMetadata.adgs.values()) {
+            statements.push((0, functionAstGeneration_1.composeAdgFunction)(adg, moduleMetadata));
+        }
+        for (const [exportName, adg] of Object.entries(moduleMetadata.exports)) {
+            statements.push((0, functionAstGeneration_1.addExportStatement)(adg.defaultGeneratedName, exportName));
+        }
+        if (input.moduleInfo.type === 'bundle') {
+            statements.push(exportNamedDeclarationForDynamicImport(input.moduleInfo.name, input.moduleInfo.namespace, input.options?.targetModule));
+        }
+    }
+    return file;
+}
+exports.generateResolvableModule = generateResolvableModule;
+/**
+ * Adds a babel import decleration to the AST for each Komaci import
+ *
+ * Note: While this method does not return anything, it does modify the input Statement array.
+ *
+ * @param {ModuleMetadata} moduleMetadata metadata about the lwc module we are building a resolvable module for
+ * @param {Statement[]} statements Array of Statement to be modified by this method for this program
+ * @param {{ calledFromGenerateCombinedModule: boolean }} options flag to distinguish whether we have been called
+ * to generate a combined module or not.
+ */
+function addImportStatements(moduleMetadata, statements, options) {
+    if (moduleMetadata.importsByName.size > 0) {
+        const imports = Array.from(moduleMetadata.importsByName.values())
+            .sort((a, b) => {
+            if (a.resourceName < b.resourceName) {
+                return -1;
+            }
+            else if (a.resourceName > b.resourceName) {
+                return 1;
+            }
+            else {
+                return 0;
+            }
+        })
+            .filter((value) => value.isFromInternalNamespace && value.usedInPriming);
+        let i = 0;
+        while (i < imports.length) {
+            const specifiers = [];
+            let resourceName = imports[i].resourceName;
+            while (i < imports.length && imports[i].resourceName === resourceName) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const localName = t.identifier(imports[i].generatorAlias);
+                let specifier;
+                const exportName = imports[i].name;
+                if (exportName === 'default') {
+                    // e.g. `import i1 from "@salesforce/user/Id";`
+                    specifier = t.importDefaultSpecifier(localName);
+                    specifiers.unshift(specifier);
+                }
+                else if (exportName === '*' &&
+                    moduleMetadata.importsByNamespace.get(resourceName)?.names.size === 1) {
+                    // e.g. `import i1 from "@salesforce/user/Id";`
+                    specifier = t.importNamespaceSpecifier(localName);
+                    specifiers.push(specifier);
+                }
+                else {
+                    // e.g. `import { getRecord as i1 } from "lightning/uiRecordApi";`.
+                    // `getRecord` is the exportName, `i1` is the localName
+                    specifier = t.importSpecifier(localName, t.identifier(exportName));
+                    specifiers.push(specifier);
+                }
+                i++;
+            }
+            if ((0, static_analyzer_1.isSupportedNamespace)(resourceName) && specifiers.length > 0) {
+                if (options.calledFromGenerateCombinedModule &&
+                    resourceName.startsWith('@salesforce/komaci')) {
+                    // @salesforce/komaci/c__foo__foo.js -> @salesforce/komaci/c__foo
+                    const lastIndex = resourceName.lastIndexOf('__');
+                    resourceName = resourceName.slice(0, lastIndex);
+                }
+                const resource = t.stringLiteral(resourceName);
+                const importDeclaration = t.importDeclaration(specifiers, resource);
+                statements.push(importDeclaration);
+            }
+        }
+    }
+}
+exports.addImportStatements = addImportStatements;
+/**
+ * Make ast statements for the details about an error we received
+ * @param adgFunc The error function metadata
+ * @param moduleMetadata metadata about the module as whole
+ * @returns ast statemenets representing config for this function node
+ */
+function processErrorFunction(adgFunc, moduleMetadata) {
+    const funcObjProps = [];
+    const t_value = t.stringLiteral(types_1.ERROR_FUNCTION);
+    const configObjExpr = valueToExpression(adgFunc.input[0], moduleMetadata);
+    funcObjProps.push(t.objectProperty(types_1.ID.FUNC_TYPE, t_value), t.objectProperty(types_1.ID.FUNC_CONFIG, configObjExpr));
+    return funcObjProps;
+}
+exports.processErrorFunction = processErrorFunction;
+/**
+ * Function to generate the object property array for a wire function node type.
+ *
+ * NOTE: if the obj representing the function is from an unsupported namespace, and it
+ * is for a wire function, then leave out the function node from the generated resolvable
+ * module, by returning undefined.
+ * @param {ImportInfo} importInfo import information against which to check the wire function's validity
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {FunctionType} adgFunc a wire function from the adg functions array.
+ * @returns {ObjectProperty[]} an representation of the wire function node as array of ObjectProperty
+ */
+function processWireFunctionType(adgFunc, moduleMetadata) {
+    // Validate and set function type, e.g. `t: "WireFunction"`
+    if (adgFunc.type !== common_shared_1.FunctionTypes.WIRE_FUNCTION &&
+        adgFunc.type !== common_shared_1.FunctionTypes.PRIMING_FUNCTION) {
+        throw new Error(common_shared_1.ERROR_PREFIX + 'ADG function has invalid type');
+    }
+    const adapterImport = moduleMetadata.importsByName.get(adgFunc.importReference.functionName);
+    if (adapterImport) {
+        const funcObjProps = [];
+        // if the obj representing the function is from an unsupported namespace, and it is for a wire function,
+        // then leave out the function node form the generated resolvable module, by returning undefined.
+        const resourceName = adapterImport.resourceName;
+        const exportName = adapterImport.name;
+        if (!exportName ||
+            !(0, static_analyzer_1.isSupportedNamespace)(resourceName) ||
+            (adgFunc.type === common_shared_1.FunctionTypes.WIRE_FUNCTION &&
+                !(0, common_shared_1.isSupportedWireAdapter)(resourceName, exportName))) {
+            return undefined;
+        }
+        if (adgFunc.type === common_shared_1.FunctionTypes.PRIMING_FUNCTION) {
+            // Add props for imports relating to this priming adapter.
+            funcObjProps.push(t.objectProperty(types_1.ID.FUNC_ID, t.identifier(adapterImport.generatorAlias)), t.objectProperty(types_1.ID.FUNC_NAME, t.stringLiteral(adgFunc.importReference.functionName)));
+            if (adgFunc.importReference.batchingName &&
+                moduleMetadata.importsByName.has(adgFunc.importReference.batchingName)) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const batchImport = moduleMetadata.importsByName.get(adgFunc.importReference.batchingName);
+                funcObjProps.push(t.objectProperty(types_1.ID.BATCH_FUNC_ID, t.identifier(batchImport.generatorAlias)), t.objectProperty(types_1.ID.BATCH_FUNC_NAME, t.stringLiteral(adgFunc.importReference.batchingName)));
+            }
+            if (adgFunc.importReference.reducer &&
+                moduleMetadata.importsByName.has(adgFunc.importReference.reducer)) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const reducerImport = moduleMetadata.importsByName.get(adgFunc.importReference.reducer);
+                funcObjProps.push(t.objectProperty(types_1.ID.REDUCER_FUNC_ID, t.identifier(reducerImport.generatorAlias)));
+            }
+            funcObjProps.push(t.objectProperty(types_1.ID.FUNC_TYPE, t.stringLiteral(types_1.PRIMING_FUNCTION)));
+        }
+        else {
+            // Traditional wire adapter.
+            funcObjProps.push(t.objectProperty(types_1.ID.FUNC_ID, t.identifier(adapterImport.generatorAlias)), t.objectProperty(types_1.ID.FUNC_NAME, t.stringLiteral(getWireName(resourceName, exportName))), t.objectProperty(types_1.ID.FUNC_TYPE, t.stringLiteral(types_1.WIRE_FUNCTION)));
+            // Check if the export name matches one of the supported context wires. If so we set
+            // wire type. e.g. `wt: "cpr"`
+            if (isSupportedContextWire(exportName)) {
+                const contextWireName = Object.keys(CONTEXT_MAPPING).find((key) => CONTEXT_MAPPING[key] === exportName);
+                if (contextWireName) {
+                    funcObjProps.push(t.objectProperty(types_1.ID.WIRE_TYPE, t.stringLiteral(contextWireName)));
+                }
+            }
+            else if (isApexWire(resourceName)) {
+                funcObjProps.push(t.objectProperty(types_1.ID.WIRE_TYPE, t.stringLiteral('apex')));
+            }
+        }
+        // Construct function to return config object and list of input properties.
+        let configObjExpr;
+        const inputProps = new Set();
+        if (adgFunc.input && adgFunc.input.length > 0) {
+            if (adgFunc.input.length !== 1 || adgFunc.input[0].type !== 'ObjectValue') {
+                // Only valid input according to Wire Adapter Protocol.
+                throw new Error(common_shared_1.ERROR_PREFIX + 'WireFunction has invalid input');
+            }
+            const inputObject = adgFunc.input[0];
+            configObjExpr = t.objectExpression([]);
+            configObjExpr = valueToExpression(inputObject, moduleMetadata); // wireconfig import usage
+            // Create list of property names which are inputs into the function.
+            for (const propValue of Object.values(inputObject.value)) {
+                // NOTE: LWC doesn't allow for property references to be nested in
+                // objects or arrays, so only need to check the top-level props.
+                if (propValue.type === 'PropertyReference') {
+                    inputProps.add(propValue.value.split('/')[0]);
+                }
+            }
+        }
+        else {
+            // Matches LWC compiler behavior which always pass an object into a wire's
+            // update() method. Even if original source doesn't provide config.
+            configObjExpr = t.objectExpression([]);
+        }
+        // e.g. `c: ctx => ({ recordId: "001RM000004UZqLYAW" })`
+        const configFunc = t.arrowFunctionExpression([types_1.ID.CONTEXT], configObjExpr);
+        funcObjProps.push(t.objectProperty(types_1.ID.FUNC_CONFIG, configFunc));
+        // e.g. in: ['recordId', 'fields']
+        if (inputProps.size) {
+            funcObjProps.push(t.objectProperty(types_1.ID.FUNC_INPUT, t.arrayExpression(Array.from(inputProps).map((v) => t.stringLiteral(v)))));
+        }
+        return funcObjProps;
+    }
+}
+exports.processWireFunctionType = processWireFunctionType;
+/**
+ * Determines whether an export name matches one of the supported context wires
+ * @param {string | undefined} exportName the exportName of an import statement
+ * @returns {boolean} boolean true if the the export name matches a supported context wire
+ */
+function isSupportedContextWire(exportName) {
+    return (exportName !== undefined && Object.values(CONTEXT_MAPPING).includes(exportName));
+}
+/**
+ * Determines whether the resourceName of an import statement is that of an Apex wire
+ * @param {string | undefined} resourceName a string representing the resource name (ex: '@salesforce/apex/myApexwire')
+ * @returns {boolean} true if the resource name represent that of an Apex wire, false otherwise
+ */
+function isApexWire(resourceName) {
+    return !!(resourceName && resourceName.startsWith('@salesforce/apex/'));
+}
+/**
+ * Retrieves the name of an Apex wire
+ * @param {string} resourceName a string representing the resource name (ex: '@salesforce/apex/ContactController.getContactList')
+ * @param {string} exportName a string representing the name of the export (ex: `awire` in `import awire from '@salesforce/apex/awire'`)
+ * @returns {string} the Apex wire name, as a string
+ */
+function getWireName(resourceName, exportName) {
+    if (isApexWire(resourceName)) {
+        // eg. @salesforce/apex/ContactController.getContactList -> ContactController.getContactList
+        return resourceName.substring('@salesforce/apex/'.length);
+    }
+    return exportName;
+}
+/**
+ * Convert any possible value within a Komaci ADG to a babel expression.
+ * @param komaciValue the komaci value
+ * @param moduleMetadata the module meta data object
+ * @returns a babel expression for the komaci value.
+ */
+function valueToExpression(komaciValue, moduleMetadata) {
+    let newExpression;
+    switch (komaciValue.type) {
+        case 'PrimitiveValue':
+            newExpression = primitiveToExpression(komaciValue);
+            break;
+        case 'ImportReference': {
+            const importIndexReference = moduleMetadata.importIndexReference.get(komaciValue.value);
+            if (importIndexReference) {
+                const importMetadata = moduleMetadata.importsByName.get(importIndexReference);
+                newExpression =
+                    importMetadata?.isFromInternalNamespace &&
+                        importMetadata?.isFromSupportedLibrary &&
+                        importMetadata.generatorAlias
+                        ? t.identifier(importMetadata.generatorAlias)
+                        : t.identifier(types_1.UNRESOLVED);
+            }
+            else {
+                newExpression = t.identifier(types_1.UNRESOLVED);
+            }
+            if (newExpression?.name !== types_1.UNRESOLVED && komaciValue.namespacedMember) {
+                newExpression = t.memberExpression(newExpression, t.identifier(komaciValue.namespacedMember));
+            }
+            break;
+        }
+        case 'PropertyReference': {
+            return bindingToExpression(komaciValue);
+        }
+        case 'Unresolved':
+            newExpression = types_1.ID.UNRESOLVED_VALUE;
+            break;
+        case 'ArrayValue': {
+            const elements = [];
+            komaciValue.value.forEach((element) => {
+                elements.push(valueToExpression(element, moduleMetadata));
+            });
+            newExpression = t.arrayExpression(elements);
+            break;
+        }
+        case 'ObjectValue': {
+            const objProps = [];
+            for (const [propName, propValue] of Object.entries(komaciValue.value)) {
+                objProps.push(t.objectProperty(t.stringLiteral(propName), valueToExpression(propValue, moduleMetadata)));
+            }
+            newExpression = t.objectExpression(objProps);
+            break;
+        }
+    }
+    if (!newExpression) {
+        throw new Error(`${common_shared_1.ERROR_PREFIX}: Unrecognized value type`);
+    }
+    return newExpression;
+}
+exports.valueToExpression = valueToExpression;
+/**
+ * Convert a Komaci primitive value to babel expression.
+ * @param primitive a primitve value
+ * @returns an expression that represents the primitive value.
+ */
+function primitiveToExpression(primitive) {
+    switch (typeof primitive.value) {
+        case 'number':
+            return t.numericLiteral(primitive.value);
+        case 'string':
+            return t.stringLiteral(primitive.value);
+        case 'boolean':
+            return t.booleanLiteral(primitive.value);
+        case 'undefined':
+            return types_1.ID.UNDEFINED;
+        default:
+            return t.nullLiteral();
+    }
+}
+exports.primitiveToExpression = primitiveToExpression;
+/**
+ * Convert binding (or PropertyReference) to a babel expr (e.g. record.value?.Id).
+ * @param binding The binding object
+ * @param iterationContext If this binding is inside an iteration we need the contextual details about the iteration to build the proper expression
+ * @param parseRootOnly There are some cases where we only care about the first piece of the binding. in the example above we might need to only check `record` instead of `record.value?.Id`
+ * @returns A composed member expression
+ */
+function bindingToExpression(binding, iterationContext, parseRootOnly = false) {
+    if (!binding.value.length) {
+        if (binding.type === 'Binding') {
+            throw new Error(common_shared_1.ERROR_PREFIX + 'encountered empty binding');
+        }
+        throw new Error(common_shared_1.ERROR_PREFIX + 'encountered empty property reference');
+    }
+    let segments = binding.value.split('/'); // segments[0] === propertyName
+    if (parseRootOnly) {
+        segments = [segments[0]];
+    }
+    let chainingStartIdx = 2;
+    let iteratorBinding = false;
+    // Am I in the context of an iteration?
+    if (iterationContext && iterationContext.includes(segments[0])) {
+        // Referencing property of an iteration
+        iteratorBinding = true; // flag to distinguish whether we are in the context of an iteration
+        chainingStartIdx = 1;
+    }
+    else {
+        chainingStartIdx = 2;
+        segments.unshift(common_shared_1.CONTEXT, common_shared_1.PROPS); // Referencing property in context, so prepend ctx.props
+    }
+    // Build member expression w/ optional chaining to prevent runtime TypeError.
+    // If we are in the context of an iterator binding, we must prepend the user variable prefix
+    let expr = iteratorBinding
+        ? t.identifier(types_1.USER_VARIABLE_PREFIX + segments[0])
+        : t.identifier(segments[0]);
+    for (let i = 1; i < segments.length; ++i) {
+        expr = t.optionalMemberExpression(expr, t.identifier(segments[i]), false, i > chainingStartIdx);
+    }
+    return expr;
+}
+exports.bindingToExpression = bindingToExpression;
+/**
+ * Convert a single Komaci function to an object expression in the shape of a
+ * FunctionDefinition as defined in Resolver API.
+ * @param {GeneratorState} generatorState the current esm generator state
+ * @param {FunctionType} adgFunc a function from the adg functions arrray.
+ * @returns {Expression} a babel Expression if propertly processed or undefined.
+ */
+function functionToExpression(moduleMetadata, adgFunc) {
+    if (adgFunc.type === common_shared_1.FunctionTypes.GETTER_FUNCTION) {
+        const getterFuncObjPropArr = processLocalFunction(adgFunc, common_shared_1.GETTER_FUNCTION);
+        return t.objectExpression(getterFuncObjPropArr);
+    }
+    else if (adgFunc.type === common_shared_1.FunctionTypes.TEMPLATE_STRING) {
+        return t.objectExpression(processLocalFunction(adgFunc, common_shared_1.TEMPLATED_STRING_FUNCTION));
+    }
+    else if (adgFunc.type === common_shared_1.FunctionTypes.ERROR) {
+        return t.objectExpression(processErrorFunction(adgFunc, moduleMetadata));
+    }
+    else if (adgFunc.type === common_shared_1.FunctionTypes.WIRE_FUNCTION ||
+        adgFunc.type === common_shared_1.FunctionTypes.PRIMING_FUNCTION) {
+        const wireFunctionObjArr = processWireFunctionType(adgFunc, moduleMetadata);
+        if (wireFunctionObjArr) {
+            return t.objectExpression(wireFunctionObjArr);
+        }
+    }
+    return undefined;
+}
+exports.functionToExpression = functionToExpression;
+/**
+ * Function to create the object property array for a local function
+ * @param {FunctionType} adgFunc a function from the adg functions array.
+ * @param {string} type The type of function. getter or templated string
+ * @returns {ObjectProperty[]} a babel object property array.
+ */
+function processLocalFunction(hoistedFunc, type) {
+    const funcObjProps = [];
+    const f_reference = {
+        type: 'Identifier',
+        name: hoistedFunc.generatedName ? hoistedFunc.generatedName : types_1.UNRESOLVED,
+        leadingComments: null,
+        innerComments: null,
+        trailingComments: null,
+        start: null,
+        end: null,
+        loc: null,
+    };
+    const t_value = t.stringLiteral(type);
+    funcObjProps.push(t.objectProperty(types_1.ID.FUNC_ID, f_reference), t.objectProperty(types_1.ID.FUNC_TYPE, t_value));
+    hoistedFunc.requiredProperties;
+    if (hoistedFunc.requiredProperties) {
+        const in_value = t.arrayExpression(hoistedFunc.requiredProperties.map((v) => t.stringLiteral(v)));
+        funcObjProps.push(t.objectProperty(types_1.ID.FUNC_INPUT, in_value));
+    }
+    return funcObjProps;
+}
+/**
+ * Convert a single Komaci property to an object expression in the shape of
+ * a PropertyDefinition as defined in Resolver API.
+ * @param {GeneratorState} generatorState the current state of esm-generator
+ * @param {Adg} adg the current ADG from which to seek out FunctionReferences
+ * @param {Propery} property the Komaci property to process
+ * @returns {Expression} the komaci property converted to an object Expression
+ */
+function propertyToExpression(moduleMetadata, property) {
+    const objProps = [];
+    // Whether the prop is public or not, e.g. `a: true`.
+    objProps.push(t.objectProperty(types_1.ID.PROP_API, t.booleanLiteral(property.isPublic)));
+    if (property.inital) {
+        // initial value
+        // Initial value of the prop, e.g. `i: 5`.
+        objProps.push(t.objectProperty(types_1.ID.PROP_INIT, valueToExpression(property.inital, moduleMetadata)));
+    }
+    if (property.type === common_shared_1.PropertyTypes.GETTER ||
+        property.type === common_shared_1.PropertyTypes.WIRE ||
+        property.type === common_shared_1.PropertyTypes.TEMPLATE_STRING) {
+        // Index of function where this property receives input, e.g. `f: 0`.
+        const funcIdx = property.functionIndex;
+        if (funcIdx === common_shared_1.UNSUPPORTED_FUNCTION) {
+            objProps.push(t.objectProperty(types_1.ID.PROP_GETTER, types_1.ID.UNRESOLVED_VALUE));
+        }
+        else {
+            objProps.push(t.objectProperty(types_1.ID.PROP_FUNC, t.numericLiteral(funcIdx)));
+        }
+    }
+    return t.objectExpression(objProps);
+}
+exports.propertyToExpression = propertyToExpression;
+/**
+ * Adds a default export to the program statements, if no default export that is derived from an AdgReference already exists
+ *
+ * @returns composed AST statement for undefined default export
+ */
+function addUndefinedDefaultExport() {
+    return t.exportDefaultDeclaration(t.functionDeclaration(null, [], t.blockStatement([t.returnStatement(types_1.ID.UNDEFINED)])));
+}
+exports.addUndefinedDefaultExport = addUndefinedDefaultExport;
+/**
+ * Adds the dynamic import of target module, but only for bundles (if moduleInfo.type === "bundle").
+ *
+ * Returns an export named declaration. The declaration is assigned an arrowFunctionExpression, which returns
+ * a dynamic import based on the moduleInfo namespace and name.
+ * @param moduleName The name of module we're making
+ * @param moduleNamespace the namespace for this given module
+ * @param targetModule name of the target module if it exists
+ * @returns ExportNamedDeclaration containing the statement of the dynamic import of the target module
+ */
+function exportNamedDeclarationForDynamicImport(moduleName, moduleNamespace, targetModule) {
+    const IMPORT_TARGET = 'importTarget';
+    const FUNC_NAME_IMPORT = 'import';
+    const CONST_TYPE = 'const';
+    const moduleResourceName = targetModule || moduleNamespace + '/' + moduleName;
+    const returnStatement = t.returnStatement(t.callExpression(t.identifier(FUNC_NAME_IMPORT), [
+        t.stringLiteral(moduleResourceName),
+    ]));
+    return t.exportNamedDeclaration(t.variableDeclaration(CONST_TYPE, [
+        t.variableDeclarator(t.identifier(IMPORT_TARGET), t.arrowFunctionExpression([], t.blockStatement([returnStatement]))),
+    ]));
+}
+exports.exportNamedDeclarationForDynamicImport = exportNamedDeclarationForDynamicImport;
+//# sourceMappingURL=genericAstGeneration.js.map

package/build/index.d.ts

@@ -1,4 +1,10 @@
 import { GeneratorInput } from './types';
 export { GeneratorInput } from './types';
 export declare function generateKomaciModule(input: GeneratorInput): string;
+/**
+ * Helper function to process and build the resolvable module based off the generator input and inital generator state.
+ * @param input the Generator input
+ * @returns the resolvable module.
+ */
+export declare function processGeneratorInputAndState(input: GeneratorInput): string;
 //# sourceMappingURL=index.d.ts.map