@komaci/esm-generator 240.1.3

package/build/modGenScript.js

@@ -0,0 +1,1027 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.produceErrorAdgFunction = exports.generateCombinedModule = exports.updateImportsWithGetterConsumption = exports.generateScriptModule = void 0;
+/* eslint-disable @typescript-eslint/no-use-before-define */
+const t = __importStar(require("@babel/types"));
+const static_analyzer_1 = require("@komaci/static-analyzer");
+const shared_1 = require("./shared");
+const types_1 = require("./types");
+const modGenTemplate_1 = require("./modGenTemplate");
+const common_shared_1 = require("@komaci/common-shared");
+const IMPORT_TARGET = 'importTarget';
+const FUNC_NAME_IMPORT = 'import';
+const CONST_TYPE = 'const';
+const CONTEXT_MAPPING = {
+    cpr: 'CurrentPageReference',
+};
+/**
+ * Generate the resolvable module for a single JS Script
+ * @param {GeneratorState} generatorState the state of the ESM generator
+ * @param {KomaciDocument} komaciDoc the KomaciDocument representation of the JS Script
+ * @returns {File} babel/types File representation of the entire JS Script. In other works, the Abstract systax tree
+ *          of the generated resolvable module.
+ */
+function generateScriptModule(generatorState, komaciDoc) {
+    const statements = [];
+    // gathers information about properties in a JS class and whether they are being used by wire functions
+    const properties = (0, common_shared_1.collectPropertyMetadataFromScriptDoc)(komaciDoc);
+    const src = (0, shared_1.getComponentSrcJs)(generatorState);
+    const moduleLevelConsumption = {
+        consumedImports: new Map(),
+    };
+    let processedGetterContext;
+    let processedTemplateStrings;
+    if (src) {
+        const ast = (0, common_shared_1.generateAstFromSrcCode)(src);
+        generatorState.scriptGenState.ast = ast;
+        const { getters, templateStrings } = (0, common_shared_1.getPropertyMetadataFromAst)(ast);
+        const moduleContext = {
+            astContext: (0, common_shared_1.getAstContextObject)(ast),
+            isExternal: (0, common_shared_1.isExternalModule)(generatorState.input.moduleInfo.namespace),
+        };
+        generatorState.scriptGenState.importMetadata =
+            moduleContext.astContext.importDeclarations;
+        // determine which getters are valid, as well as which imports are being by those getters
+        processedGetterContext = (0, shared_1.processGetters)(properties, moduleContext, moduleLevelConsumption, getters);
+        processedTemplateStrings = (0, shared_1.processTemplateStrings)(properties, moduleContext, moduleLevelConsumption, templateStrings);
+        // once we know what getters are using which imports, modify the functions array in the komaci documents
+        // (in memory) as well property references in the Properties array
+        updateImportsWithGetterConsumption(komaciDoc, moduleLevelConsumption.consumedImports);
+        (0, shared_1.updateKomaciDocumentWithValidGetters)(komaciDoc, processedGetterContext);
+        (0, shared_1.updateKomaciDocumentWithValidTemplatedStrings)(komaciDoc, processedTemplateStrings);
+    }
+    // Import default composition if not in-lined into the ADGs.
+    importDefaultCompositionIfNotInlinedIntoADG(generatorState, komaciDoc.adgs, statements);
+    // Add import declarations for all the Imports in the Komaci doc.
+    addImportStatements(generatorState, komaciDoc, statements, moduleLevelConsumption, properties, {
+        calledFromGenerateCombinedModule: false,
+    });
+    // Create map that maintains adg indexes to it's names
+    createAdgNameMap(generatorState, komaciDoc);
+    // Process the exports in the Komaci doc, including the Adgs which are being exported.
+    processExports(generatorState, komaciDoc, statements);
+    // Process the adgs that are not exported.
+    processNonExportAdgs(generatorState, komaciDoc, statements);
+    // add default export from AdgReference (if not already added).
+    addDefaultExportFromAdgReferenceIfNoneExists(generatorState, statements);
+    // remove invalid imports that are only used in wire adapters
+    removeInvalidImportsOnlyUsedInWireAdapter(generatorState, statements);
+    // append priming adapter imports and perform any final changes and return generated source file
+    const generatedFile = appendPrimingAdapterImportsAndGenerateFinalFile(generatorState, statements);
+    // transform getters in the generated source file AST by hoisting them to the module level
+    if (processedGetterContext &&
+        generatorState.scriptGenState.ast &&
+        generatorState.scriptGenState.importMetadata &&
+        generatedFile) {
+        // needs fully generated, final source file AST, so transformGetters call is done last
+        (0, shared_1.transformGetters)(generatedFile, generatorState.scriptGenState.importRefsMap, generatorState.scriptGenState.importMetadata, processedGetterContext);
+    }
+    if (processedTemplateStrings &&
+        generatorState.scriptGenState.ast &&
+        generatorState.scriptGenState.importMetadata &&
+        generatedFile) {
+        (0, shared_1.hoistTemplateStrings)(generatedFile, generatorState.scriptGenState.importRefsMap, generatorState.scriptGenState.importMetadata, processedTemplateStrings);
+    }
+    return generatedFile;
+}
+exports.generateScriptModule = generateScriptModule;
+/**
+ * Given information about what imports a getter consumes, we check the komaci doc to make sure all the
+ * import info is available
+ * @param komaciScriptDoc The Komaci doc to process
+ * @param consumedImports metadata about getter import consumption
+ */
+function updateImportsWithGetterConsumption(komaciScriptDoc, consumedImports) {
+    if (!komaciScriptDoc.imports) {
+        komaciScriptDoc.imports = [];
+    }
+    for (const consumedImportInfo of consumedImports.values()) {
+        const index = komaciScriptDoc.imports.findIndex((current) => current.resourceName === consumedImportInfo.resourceName);
+        if (index !== -1 && !consumedImportInfo.isNamespaceSpecifier) {
+            // we update komaciScriptDoc with any import specs that might be missing, from the getter
+            // consumption, and not the other way around
+            const komaciImportSpecifiers = new Set(komaciScriptDoc.imports[index].names);
+            const consumedImportsSpecifiers = Array.from(consumedImportInfo.names);
+            consumedImportsSpecifiers.forEach((consumedSpec) => {
+                if (!komaciImportSpecifiers.has(consumedSpec) &&
+                    komaciScriptDoc?.imports) {
+                    komaciScriptDoc.imports[index].names.push(consumedSpec);
+                }
+            });
+        }
+        else if (index !== -1 && consumedImportInfo.isNamespaceSpecifier) {
+            komaciScriptDoc.imports[index].names = ['*'];
+        }
+        else if (consumedImportInfo.isNamespaceSpecifier) {
+            komaciScriptDoc.imports.push({
+                resourceName: consumedImportInfo.resourceName,
+                names: ['*'],
+            });
+        }
+        else {
+            komaciScriptDoc.imports.push({
+                resourceName: consumedImportInfo.resourceName,
+                names: Array.from(consumedImportInfo.names),
+            });
+        }
+    }
+}
+exports.updateImportsWithGetterConsumption = updateImportsWithGetterConsumption;
+/**
+ * Generates the resolvable runtime module for a script and template file.
+ * @param {GeneratorState} generatorState the state of the ESM generator
+ * @param {KomaciDocument} komaciScriptDoc the Komaci doc for the script file
+ * @param {KomaciDocument} komaciTemplateDoc the Komaci doc for the template file
+ * @returns babel/types File representing the generated, combined resolvable runtime module. In other words,
+ * the Abstract Syntax Tree of the combined, resolvable module.
+ */
+function generateCombinedModule(generatorState, komaciScriptDoc, komaciTemplateDoc) {
+    // script module generation code
+    const statements = [];
+    // gathers information about properties in a JS class and whether they are being used by wire functions
+    const properties = (0, common_shared_1.collectPropertyMetadataFromScriptDoc)(komaciScriptDoc);
+    (0, common_shared_1.updatePropertyMetadataFromTemplateDoc)(komaciTemplateDoc, properties);
+    const src = (0, shared_1.getComponentSrcJs)(generatorState);
+    const moduleLevelConsumption = {
+        consumedImports: new Map(),
+    };
+    let processedGetterContext;
+    let processedTemplateStrings;
+    if (src) {
+        const ast = (0, common_shared_1.generateAstFromSrcCode)(src);
+        const { getters, templateStrings } = (0, common_shared_1.getPropertyMetadataFromAst)(ast);
+        generatorState.scriptGenState.ast = ast;
+        const moduleContext = {
+            astContext: (0, common_shared_1.getAstContextObject)(ast),
+            isExternal: (0, common_shared_1.isExternalModule)(generatorState.input.moduleInfo.namespace),
+        };
+        generatorState.scriptGenState.importMetadata =
+            moduleContext.astContext.importDeclarations;
+        // determine which getters are valid, as well as which imports are being by those getters
+        processedGetterContext = (0, shared_1.processGetters)(properties, moduleContext, moduleLevelConsumption, getters);
+        processedTemplateStrings = (0, shared_1.processTemplateStrings)(properties, moduleContext, moduleLevelConsumption, templateStrings);
+        // once we know what getters are using which imports, modify the functions array in the komaci documents
+        // (in memory) as well property references in the Properties array
+        updateImportsWithGetterConsumption(komaciScriptDoc, moduleLevelConsumption.consumedImports);
+        (0, shared_1.updateKomaciDocumentWithValidGetters)(komaciScriptDoc, processedGetterContext);
+        (0, shared_1.updateKomaciDocumentWithValidTemplatedStrings)(komaciScriptDoc, processedTemplateStrings);
+    }
+    generatorState.inlineTemplateDoc = komaciTemplateDoc;
+    if (doesScriptHaveADGs(komaciScriptDoc)) {
+        (0, modGenTemplate_1.processTemplateImports)(komaciTemplateDoc, generatorState, statements);
+    }
+    // Add import declarations for all the Imports in the Komaci doc.
+    addImportStatements(generatorState, komaciScriptDoc, statements, moduleLevelConsumption, properties, {
+        calledFromGenerateCombinedModule: true,
+    });
+    // Create map that maintains adg indexes to it's names
+    createAdgNameMap(generatorState, komaciScriptDoc);
+    // Process the exports in the Komaci doc, including the Adgs which are being exported.
+    processExports(generatorState, komaciScriptDoc, statements);
+    // Process the adgs that are not exported.
+    processNonExportAdgs(generatorState, komaciScriptDoc, statements);
+    // add default export if not already added.
+    addDefaultExportFromAdgReferenceIfNoneExists(generatorState, statements);
+    // add dynamic import for target module (for bundle only)
+    addDynamicImportOfTargetModuleForBundle(generatorState, statements);
+    // remove invalid imports that are only used in a wire adapter
+    removeInvalidImportsOnlyUsedInWireAdapter(generatorState, statements);
+    // append priming adapter imports and perform any final changes and return generated source file
+    const generatedFile = appendPrimingAdapterImportsAndGenerateFinalFile(generatorState, statements);
+    // transform getters in the generated source file AST by hoisting them to the module level
+    if (processedGetterContext &&
+        generatorState.scriptGenState.ast &&
+        generatorState.scriptGenState.importMetadata &&
+        generatedFile) {
+        // needs fully generated source file AST, so transformGetters call is last
+        (0, shared_1.transformGetters)(generatedFile, generatorState.scriptGenState.importRefsMap, generatorState.scriptGenState.importMetadata, processedGetterContext);
+    }
+    if (processedTemplateStrings &&
+        generatorState.scriptGenState.ast &&
+        generatorState.scriptGenState.importMetadata &&
+        generatedFile) {
+        (0, shared_1.hoistTemplateStrings)(generatedFile, generatorState.scriptGenState.importRefsMap, generatorState.scriptGenState.importMetadata, processedTemplateStrings);
+    }
+    return generatedFile;
+}
+exports.generateCombinedModule = generateCombinedModule;
+/**
+ * Performs any remaining modifications and creates a final File representing the entire program.
+ *
+ * @param {GeneratorState} generatorState the GeneratorState for this module generation run
+ * @param {Statement[]} statements t.Statement[] the statements of the analyzed program, up to this point
+ * @returns babel/types File, i.e. the AST of generated resolvable module
+ */
+function appendPrimingAdapterImportsAndGenerateFinalFile(generatorState, statements) {
+    // append import statements for priming adapters
+    const allStatements = [
+        ...generatorState.scriptGenState.primingAdapterImportDeclarations,
+        ...statements,
+    ];
+    // generate the program
+    const program = t.program(allStatements);
+    const file = t.file(program);
+    return file;
+}
+/**
+ * Removes invalid imports (or import specifiers therein) that are only used in wire adapter annotation (and nowhere else).
+ *
+ * Note: While this method does not return anything, it does modify the input Statement array.
+ *
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Statement[]} statements t.Statement[] the statements of the analyzed program, up to this point.
+ */
+function removeInvalidImportsOnlyUsedInWireAdapter(generatorState, statements) {
+    // gather all of the ImportInfos for the ImportSpecifiers that should be removed
+    const importInfosToRemove = findImportInfosToRemove(generatorState);
+    // remove ImportSpecifiers and ImportDeclarations as appropriate
+    for (const importInfo of importInfosToRemove) {
+        const importDeclaration = importInfo.importDeclaration;
+        if (importDeclaration?.specifiers && importInfo.importSpecifier) {
+            importDeclaration.specifiers.splice(importDeclaration.specifiers.indexOf(importInfo.importSpecifier), 1);
+        }
+        if (importDeclaration?.specifiers.length === 0) {
+            // there are no more valid wire adapters left as specifiers, remove whole import statement
+            statements.splice(statements.indexOf(importDeclaration), 1);
+        }
+    }
+    return;
+}
+/**
+ * Finds the ImportInfos of the ImportSpecifiers that need to be removed due not representing a
+ * supported wire adapter.
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @returns ImportInfo[] corresponding to all ImportSpecifiers that need to be removed because they
+ * represent unsupported wire adapters
+ */
+function findImportInfosToRemove(generatorState) {
+    const importInfosToRemove = [];
+    for (const importInfo of generatorState.scriptGenState.importInfosForWireAdapter) {
+        // if it's used by something other than a wire adapter, we can't remove it, so might as well skip this iteration.
+        if (importInfo.importUsages.size > 1) {
+            continue;
+        }
+        if (importInfo.primingAdapterImportNames) {
+            // if it's for a priming adapter then we want to remove the
+            // import for the original wire adapter.
+            importInfosToRemove.push(importInfo);
+        }
+        else if (importInfo.importSpecifier.type === 'ImportSpecifier') {
+            // if it's not a supported wire adapter, remove it.
+            const identifier = (importInfo.importSpecifier.imported);
+            const exportName = identifier.name;
+            if (!(0, static_analyzer_1.isSupportedWireAdapter)(importInfo.resourceName, exportName)) {
+                importInfosToRemove.push(importInfo);
+            }
+        }
+    }
+    return importInfosToRemove;
+}
+/**
+ * Determines whether Komaci JS document has any ADGs defined within it
+ * @param {KomaciDocument} komaciScriptDoc a KomaciDocument representation of a Javascript project
+ * @returns boolean true is the Komaci JS document has any ADGs defined within it
+ */
+function doesScriptHaveADGs(komaciScriptDoc) {
+    return (komaciScriptDoc.adgs?.length || 0) > 0;
+}
+/**
+ * Detects if the composition has not been in-lined into the ADG(s).
+ * If not, then generate an import declaration for the default composition file.
+ *
+ * Note: While this method does not return anything, it does modify the input Statement array.
+ *
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Adg[] | undefined} adgs an array of Adg in which to search for compositions
+ * @param {Statement[]} statements Array of Statement to be modified by this method
+ */
+function importDefaultCompositionIfNotInlinedIntoADG(generatorState, adgs, statements) {
+    if (adgs) {
+        const adgNoComposition = adgs.find((adg) => {
+            return !adg.compositions || adg.compositions.length === 0;
+        });
+        if (adgNoComposition) {
+            // If we find adg without composition, then we'll need to import
+            // it in order to be referenced later.
+            const namespace = generatorState.input.moduleInfo.namespace;
+            const name = generatorState.input.moduleInfo.name;
+            const resource = t.stringLiteral(`@salesforce/komaci/${namespace}__${name}__${name}.html`);
+            statements.push(t.importDeclaration([t.importDefaultSpecifier(shared_1.ID.DEFAULT_COMP)], resource));
+            generatorState.defaultCompImported = true;
+        }
+    }
+}
+/**
+ * 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 {GeneratorState} generatorState the current state of the esm generator
+ * @param {KomaciDocument} komaciScriptDoc the Komaci doc for the script file
+ * @param {Statement[]} statements Array of Statement to be modified by this method for this program
+ * @param {ModuleLevelConsumption | undefined} moduleLevelConsumption ModuleLevelConsumption object containing the Map of
+ * imports which are being consumed
+ * @param {ClassPropertyContexts} properties Map of class properties and all their relevant metadata
+ * @param {{ calledFromGenerateCombinedModule: boolean }} options flag to distinguish whether we have been called
+ * to generate a combined module or not.
+ */
+function addImportStatements(generatorState, komaciScriptDoc, statements, moduleLevelConsumption, properties, options) {
+    const imports = komaciScriptDoc.imports;
+    if (imports) {
+        for (let importIdx = 0; importIdx < imports.length; ++importIdx) {
+            // outer for loop for import statement
+            const komaciImport = imports[importIdx];
+            const specifiers = [];
+            const importInfosForDecl = [];
+            for (let nameIdx = 0; nameIdx < komaciImport.names.length; ++nameIdx) {
+                // inner for loop for import specifiers
+                const exportName = komaciImport.names[nameIdx];
+                if ((0, static_analyzer_1.isSupportedNamespace)(komaciImport.resourceName)) {
+                    ++generatorState.importAliasSuffix;
+                }
+                const localName = (0, static_analyzer_1.isSupportedNamespace)(komaciImport.resourceName)
+                    ? t.identifier(`i${generatorState.importAliasSuffix}`)
+                    : t.identifier(shared_1.UNRESOLVED);
+                let specifier;
+                if (exportName === 'default') {
+                    // e.g. `import i1 from "@salesforce/user/Id";`
+                    specifier = t.importDefaultSpecifier(localName);
+                    specifiers.unshift(specifier);
+                }
+                else if (exportName === '*' && komaciImport.names.length === 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);
+                }
+                const importInfo = {
+                    localName,
+                    resourceName: komaciImport.resourceName,
+                    exportName: exportName,
+                    importUsages: new Set(),
+                    importSpecifier: specifier,
+                    importDeclaration: undefined,
+                };
+                // Helpful state for translation between import ref and local name.
+                const importRefId = `${importIdx}/names/${nameIdx}`;
+                // skip this if it is an import, whose export is assigned to a memeber, but that member is not used in either a
+                // wire input, or in a composition.
+                generatorState.scriptGenState.importRefsMap[importRefId] = importInfo;
+                // store the ImportInfo in the area for later use
+                importInfosForDecl.push(importInfo);
+            } // end import inner loop for exports
+            // only write the import statement if it is from a supported
+            // namespace (in lines above, we still keep the state in the importRefsMap)
+            let resourceName = komaciImport.resourceName;
+            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);
+                // this object here will need to go into importInfo so it can be located/removed from the statements array later
+                importInfosForDecl.forEach((importInfo) => {
+                    importInfo.importDeclaration = importDeclaration;
+                });
+            }
+        } // end import outer loop for import declarations
+    }
+}
+/**
+ * Creates a Map that maintains ADG indexes to its corresponding names, generating a new
+ * entry if it is not available
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {KomaciDocument} komaciScriptDoc the Komaci doc for the script file
+ */
+function createAdgNameMap(generatorState, komaciScriptDoc) {
+    const exports = komaciScriptDoc.exports;
+    if (exports) {
+        Object.keys(exports).forEach((key) => {
+            const keyedExport = exports[key];
+            if (keyedExport && keyedExport.type === 'AdgReference') {
+                generatorState.adgNameMap[keyedExport.value] = key;
+            }
+        });
+    }
+    // generate names if it is not avaialble
+    komaciScriptDoc.adgs?.forEach((_adg, index) => {
+        if (!generatorState.adgNameMap[index]) {
+            generatorState.adgNameMap[index] = 'adg' + index;
+        }
+    });
+}
+/**
+ * Process exports in the Komaci Script document, which produces functions to return ADG definitions
+ *
+ * Note: While this method does not return anything, it does modify the input Statement array.
+ *
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {KomaciDocument} komaciScriptDoc the Komaci doc for the script file
+ * @param {Statement[]} statements Array of Statement to be modified by this method for this program
+ */
+function processExports(generatorState, komaciScriptDoc, statements) {
+    if (komaciScriptDoc.exports) {
+        for (const [exportName, komaciExport] of Object.entries(komaciScriptDoc.exports)) {
+            if (komaciExport &&
+                (komaciExport.type === 'AdgReference' ||
+                    komaciExport.type === 'CompositionReference')) {
+                // Validate integrity of komaci doc.
+                if (!komaciScriptDoc.adgs ||
+                    komaciExport.value < 0 ||
+                    komaciExport.value > komaciScriptDoc.adgs.length) {
+                    throw new Error(shared_1.ERROR_PREFIX +
+                        'komaciDoc contains invalid ADG or composition references');
+                }
+                // For each exported Adg create a corresponding export of a function
+                // which returns the AdgDefinition described in Resolver API.
+                const komaciAdg = komaciScriptDoc.adgs[komaciExport.value];
+                const body = getAdgFunctionBody(generatorState, komaciAdg);
+                if (exportName === 'default') {
+                    generatorState.isDefaultExportFound = true;
+                    // e.g. `export default function (fct, ctx) {`
+                    statements.push(t.exportDefaultDeclaration(t.functionDeclaration(null, [shared_1.ID.FACTORY, shared_1.ID.CONTEXT], body)));
+                }
+                else {
+                    // e.g. `export function MyComponentClass(fct, ctx) {`
+                    statements.push(t.exportNamedDeclaration(t.functionDeclaration(t.identifier(exportName), [shared_1.ID.FACTORY, shared_1.ID.CONTEXT], body)));
+                }
+            }
+        }
+    }
+}
+/**
+ * Processes the ADGs that are not exported
+ *
+ * Note: While this method does not return anything, it does modify the input Statement array.
+ *
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {KomaciDocument} komaciScriptDoc the Komaci doc for the script file
+ * @param {Statement[]} statements Array of Statement to be modified by this method for this program
+ */
+function processNonExportAdgs(generatorState, komaciScriptDoc, statements) {
+    komaciScriptDoc.adgs?.forEach((adg, index) => {
+        const localGeneratedName = generatorState.adgNameMap[index];
+        if (localGeneratedName.startsWith('adg')) {
+            const body = getAdgFunctionBody(generatorState, adg);
+            statements.push(t.functionDeclaration(t.identifier(localGeneratedName), [shared_1.ID.FACTORY, shared_1.ID.CONTEXT], body));
+        }
+    });
+}
+/**
+ * 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
+ */
+function getAdgFunctionBody(generatorState, adg) {
+    const adgFuncCall = adgToExpression(generatorState, adg);
+    const fctFuncs = (0, shared_1.getFactoryFuncDeclaration)(generatorState, true);
+    const funcStatements = [];
+    const body = t.blockStatement(funcStatements);
+    // Function body will be destructuring of factory object and the return
+    // statement for the adg() function call from Resolver API.
+    // e.g. `{ const { adg } = fct; return adg({...}); }`
+    if (fctFuncs) {
+        funcStatements.push(fctFuncs);
+    }
+    funcStatements.push(t.returnStatement(adgFuncCall));
+    return body;
+}
+/**
+ * Adds a default export to the program statements, if no default export that is derived from an AdgReference already exists
+ *
+ * Note: While this method does not return anything, it does modify the input Statement array.
+ *
+ * @param {GeneratorState} generatorState The GeneratorState, from which the moduleInfo type is checked
+ * @param {Statement[]} statements The babel/types array of Statement, representing statements of the JS Script
+ */
+function addDefaultExportFromAdgReferenceIfNoneExists(generatorState, statements) {
+    // If no default export of an AdgReference (e.g. an LWC library module) currently exists, then we
+    // must still include one within the generated module.
+    if (!generatorState.isDefaultExportFound) {
+        statements.push(
+        // `export default function () { return undefined; }`
+        t.exportDefaultDeclaration(t.functionDeclaration(null, [], t.blockStatement([t.returnStatement(shared_1.ID.UNDEFINED)]))));
+    }
+}
+/**
+ * Adds the dynamic import of target module, but only for bundles (if moduleInfo.type === "bundle").
+ * This method modifies the input statements array, and does not return anything.
+ *
+ * Note: While this method does not return anything, it does modify the input Statement array.
+ *
+ * @param {GeneratorState} generatorState The GeneratorState, from which the moduleInfo type is checked
+ * @param {Statement[]} statements The babel/types array of Statement, representing statements of the JS Script
+ */
+function addDynamicImportOfTargetModuleForBundle(generatorState, statements) {
+    // dynamic import of target module (generated only if moduleInfo.type is "bundle")
+    // e.g.
+    // ```
+    // export const importTarget = () => {
+    //   return import("lightning/input");
+    // };
+    // ```
+    if (generatorState?.input?.moduleInfo?.type === 'bundle') {
+        statements.push(exportNamedDeclarationForDynamicImport(generatorState));
+    }
+}
+/**
+ * Returns an export named declaration. The declaration is assigned an arrowFunctionExpression, which returns
+ * a dynamic import based on the moduleInfo namespace and name.
+ * @param generatorState The GeneratorState, from which the resourceName for the import is determined
+ * @returns ExportNamedDeclaration containing the statement of the dynamic import of the target module
+ */
+function exportNamedDeclarationForDynamicImport(generatorState) {
+    const moduleResourceName = generatorState.input.options?.targetModule ||
+        generatorState.input.moduleInfo?.namespace +
+            '/' +
+            generatorState.input.moduleInfo?.name;
+    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]))),
+    ]));
+}
+/**
+ * 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
+ */
+function adgToExpression(generatorState, adg) {
+    const params = [];
+    generatorState.scriptGenState.requiredFactoryFunctions.add(shared_1.ID.ADG_FUNC);
+    // arg1: Parent Class.
+    if (adg.parentClass) {
+        let exp;
+        if (adg.parentClass.type === 'Unresolved') {
+            generatorState.scriptGenState.requiredFactoryFunctions.add(shared_1.ID.UNRESOLVED_VALUE);
+            params.push(shared_1.ID.UNRESOLVED_VALUE);
+        }
+        else if (adg.parentClass.type === 'ImportReference' &&
+            !(0, static_analyzer_1.isSupportedNamespace)(generatorState.scriptGenState.importRefsMap[adg.parentClass.value]
+                ?.resourceName)) {
+            generatorState.scriptGenState.requiredFactoryFunctions.add(shared_1.ID.UNRESOLVED_VALUE);
+            params.push(shared_1.ID.UNRESOLVED_VALUE);
+        }
+        else {
+            if (adg.parentClass.type === 'AdgReference') {
+                const name = generatorState.adgNameMap[adg.parentClass.value];
+                exp = t.identifier(name);
+            }
+            else {
+                exp = (0, shared_1.valueToExpression)(generatorState, adg.parentClass, true, types_1.ImportUsageState.parentadg);
+            }
+            const parentFunc = t.callExpression(exp, [shared_1.ID.FACTORY, shared_1.ID.CONTEXT]);
+            params.push(parentFunc);
+        }
+    }
+    else {
+        params.push(shared_1.ID.UNDEFINED);
+    }
+    // arg2: Properties object.
+    if (adg.properties) {
+        const objProps = [];
+        for (const [propName, propValue] of Object.entries(adg.properties)) {
+            objProps.push(t.objectProperty(t.identifier(propName), propertyToExpression(generatorState, adg, propValue)));
+        }
+        params.push(t.objectExpression(objProps));
+    }
+    else {
+        params.push(t.objectExpression([]));
+    }
+    // arg3: Functions array.
+    const functionsArray = [];
+    if (adg.functions) {
+        adg.functions.forEach((adgFunc) => {
+            const expr = functionToExpression(generatorState, adgFunc);
+            if (expr) {
+                functionsArray.push(expr);
+            }
+            else {
+                functionsArray.push(null);
+            }
+        });
+    }
+    if (functionsArray.length) {
+        params.push(t.arrayExpression(functionsArray));
+    }
+    else {
+        params.push(t.arrayExpression([]));
+    }
+    // arg4: Imported in-line composition function.
+    if (generatorState && generatorState.inlineTemplateDoc) {
+        const compositions = [];
+        if (generatorState.inlineTemplateDoc.compositions &&
+            generatorState.inlineTemplateDoc.compositions.length > 0) {
+            // current assumption: comp for templateDoc is in first element
+            compositions.push(generatorState.inlineTemplateDoc.compositions[0]);
+        } // otherwise, if we are processing an empty in-line templateDoc, pass in an empty array
+        params.push(getInlineFunctionFromTemplateCompositions(generatorState, compositions));
+    }
+    else if (generatorState.defaultCompImported) {
+        params.push(shared_1.ID.DEFAULT_COMP);
+    }
+    // arg5: pass properties that the template references (only if processing a bundle)
+    if (generatorState.input.moduleInfo.type === 'bundle') {
+        // this array of t.stringLiterals may include properties mentioned the Template that aren't necessarily
+        // defined in the Script. Resolution engine has logic to handle these
+        params.push(t.arrayExpression(Array.from(generatorState.templateGenState.refProps).map((v) => t.stringLiteral(v))));
+    }
+    else {
+        params.push(t.arrayExpression([]));
+    }
+    return t.callExpression(shared_1.ID.ADG_FUNC, params);
+}
+/**
+ * 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
+ */
+function getInlineFunctionFromTemplateCompositions(generatorState, compositions) {
+    const params = [shared_1.ID.FACTORY, shared_1.ID.CONTEXT];
+    const statements = [];
+    const body = t.blockStatement(statements);
+    const emptyCompositionsArray = compositions.length < 1;
+    const compositionArrayExpr = emptyCompositionsArray
+        ? t.arrayExpression([])
+        : (0, modGenTemplate_1.compositionsToArrayExpression)(generatorState, true, compositions) ||
+            t.arrayExpression([]);
+    // function body destructured factory object. e.g. `const { cg } = fct;`
+    const fctFuncs = (0, shared_1.getFactoryFuncDeclaration)(generatorState, false); // passing in false because we are not processing the script file in this method
+    if (fctFuncs && !emptyCompositionsArray) {
+        statements.push(fctFuncs);
+    }
+    statements.push(t.returnStatement(compositionArrayExpr));
+    return t.arrowFunctionExpression(params, body);
+}
+/**
+ * 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(generatorState, adg, property) {
+    const objProps = [];
+    // Whether the prop is public or not, e.g. `a: true`.
+    objProps.push(t.objectProperty(shared_1.ID.PROP_API, t.booleanLiteral(!!property.isPublic)));
+    if (property.initial) {
+        // initial value
+        // Initial value of the prop, e.g. `i: 5`.
+        objProps.push(t.objectProperty(shared_1.ID.PROP_INIT, (0, shared_1.valueToExpression)(generatorState, property.initial, true, types_1.ImportUsageState.initialvalue)));
+    }
+    if (property.input) {
+        if (property.input.type === 'FunctionReference') {
+            // Index of function where this property receives input, e.g. `f: 0`.
+            const funcIdx = property.input.value;
+            if (!adg.functions || funcIdx < 0 || funcIdx >= adg.functions.length) {
+                throw new Error(shared_1.ERROR_PREFIX + 'komaciDoc contains invalid function reference');
+            }
+            // if the property input type is a FunctionReference that refers to a Wire Function, then make sure its
+            // corresponding ImportReference does not refer to a unsupported resourceName; if it does, then
+            // replace the `f: functionIndex`, with `g: unresolved`
+            const resourceKey = adg.functions[funcIdx].reference.value;
+            const importInfo = (0, shared_1.retrieveImportInfo)(generatorState, resourceKey, true);
+            const resourceName = importInfo?.resourceName;
+            const exportName = importInfo?.exportName;
+            if (adg.functions[funcIdx].type == shared_1.WIRE_FUNCTION &&
+                (adg.functions[funcIdx].reference.type === 'Unresolved' ||
+                    !(0, static_analyzer_1.isSupportedNamespace)(resourceName) ||
+                    !(0, static_analyzer_1.isSupportedWireAdapter)(resourceName, exportName))) {
+                objProps.push(t.objectProperty(shared_1.ID.PROP_GETTER, shared_1.ID.UNRESOLVED_VALUE));
+                generatorState.scriptGenState.requiredFactoryFunctions.add(shared_1.ID.UNRESOLVED_VALUE);
+            }
+            else {
+                objProps.push(t.objectProperty(shared_1.ID.PROP_FUNC, t.numericLiteral(funcIdx)));
+            }
+        }
+        else {
+            // setting up modgen for getter (static values returned via getter)
+            // If associated w/ getter, then the hardcoded value from the getter,
+            // e.g. `g: 'some hardcoded string'`
+            objProps.push(t.objectProperty(shared_1.ID.PROP_GETTER, (0, shared_1.valueToExpression)(generatorState, property.input, true, types_1.ImportUsageState.getter)));
+        }
+    }
+    return t.objectExpression(objProps);
+}
+/**
+ * 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(generatorState, 
+// eslint-disable-next-line @typescript-eslint/ban-types
+adgFunc) {
+    let importInfo;
+    if (adgFunc.type === shared_1.GETTER_FUNCTION) {
+        const getterFuncObjPropArr = processLocalFunction(adgFunc, shared_1.GETTER_FUNCTION);
+        return t.objectExpression(getterFuncObjPropArr);
+    }
+    else if (adgFunc.type === shared_1.TEMPLATED_STRING_FUNCTION) {
+        return t.objectExpression(processLocalFunction(adgFunc, shared_1.TEMPLATED_STRING_FUNCTION));
+    }
+    else if (adgFunc.type === shared_1.ERROR_FUNCTION) {
+        return t.objectExpression(processErrorFunction(generatorState, adgFunc));
+    }
+    // Use import map to set function id to local alias name, e.g. `f: i1`.
+    if (adgFunc.reference.type === 'ImportReference') {
+        importInfo = (0, shared_1.updateImportInfoState)(generatorState, adgFunc.reference.value, true, types_1.ImportUsageState.wireadapter); // wireadapter import usage
+    }
+    else {
+        // UnresolvedValue
+        return undefined;
+    }
+    // Validate and set function type, e.g. `t: "WireFunction"`
+    if (adgFunc.type !== shared_1.WIRE_FUNCTION) {
+        throw new Error(shared_1.ERROR_PREFIX + 'ADG function has invalid type');
+    }
+    const wireFunctionObjArr = processWireFunctionType(importInfo, generatorState, adgFunc);
+    if (wireFunctionObjArr) {
+        return t.objectExpression(wireFunctionObjArr);
+    }
+    return undefined;
+}
+function processErrorFunction(generatorState, adgFunc) {
+    const funcObjProps = [];
+    const t_value = t.stringLiteral(shared_1.ERROR_FUNCTION);
+    const configObjExpr = (0, shared_1.valueToExpression)(generatorState, 
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    adgFunc.input[0], true, types_1.ImportUsageState.initialvalue);
+    funcObjProps.push(t.objectProperty(shared_1.ID.FUNC_TYPE, t_value), t.objectProperty(shared_1.ID.FUNC_CONFIG, configObjExpr));
+    return funcObjProps;
+}
+/**
+ * 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(adgFunc, type) {
+    const funcObjProps = [];
+    const f_reference = {
+        type: 'Identifier',
+        name: adgFunc.reference.value,
+        leadingComments: null,
+        innerComments: null,
+        trailingComments: null,
+        start: null,
+        end: null,
+        loc: null,
+    };
+    const t_value = t.stringLiteral(type);
+    funcObjProps.push(t.objectProperty(shared_1.ID.FUNC_ID, f_reference), t.objectProperty(shared_1.ID.FUNC_TYPE, t_value));
+    if (adgFunc.input) {
+        const inputArray = adgFunc.input.filter((entry) => entry.type === 'ArrayValue')[0];
+        const in_value = t.arrayExpression(inputArray.value.map((v) => t.stringLiteral(v.value)));
+        funcObjProps.push(t.objectProperty(shared_1.ID.FUNC_INPUT, in_value));
+    }
+    return funcObjProps;
+}
+/**
+ * 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(importInfo, generatorState, adgFunc) {
+    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 = importInfo.resourceName;
+    const exportName = importInfo.exportName;
+    if (!exportName ||
+        !(0, static_analyzer_1.isSupportedNamespace)(resourceName) ||
+        !(0, static_analyzer_1.isSupportedWireAdapter)(resourceName, exportName)) {
+        return undefined;
+    }
+    // If we don't already know, check to see if this is a priming adapter.
+    if (!importInfo.primingAdapterImportNames) {
+        const primingAdapterDef = (0, static_analyzer_1.getPrimingAdapter)(resourceName, exportName);
+        if (primingAdapterDef) {
+            // create imports and store local names in this importInfo.
+            importInfo.primingAdapterImportNames = createPrimingAdapterImports(generatorState, primingAdapterDef);
+        }
+    }
+    if (importInfo.primingAdapterImportNames) {
+        const primingAdapterDef = importInfo.primingAdapterImportNames.primingAdapterDef;
+        // Add props for imports relating to this priming adapter.
+        funcObjProps.push(t.objectProperty(shared_1.ID.FUNC_ID, importInfo.primingAdapterImportNames.adapter), t.objectProperty(shared_1.ID.FUNC_NAME, t.stringLiteral(primingAdapterDef.prime.identifier)));
+        if (importInfo.primingAdapterImportNames.batchAdapter &&
+            primingAdapterDef.batch) {
+            funcObjProps.push(t.objectProperty(shared_1.ID.BATCH_FUNC_ID, importInfo.primingAdapterImportNames.batchAdapter), t.objectProperty(shared_1.ID.BATCH_FUNC_NAME, t.stringLiteral(primingAdapterDef.batch.prime.identifier)));
+        }
+        if (importInfo.primingAdapterImportNames.reducer) {
+            funcObjProps.push(t.objectProperty(shared_1.ID.REDUCER_FUNC_ID, importInfo.primingAdapterImportNames.reducer));
+        }
+        funcObjProps.push(t.objectProperty(shared_1.ID.FUNC_TYPE, t.stringLiteral(shared_1.PRIMING_FUNCTION)));
+    }
+    else {
+        // Traditional wire adapter.
+        funcObjProps.push(t.objectProperty(shared_1.ID.FUNC_ID, importInfo.localName), t.objectProperty(shared_1.ID.FUNC_NAME, t.stringLiteral(getWireName(resourceName, exportName))), t.objectProperty(shared_1.ID.FUNC_TYPE, t.stringLiteral(shared_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(shared_1.ID.WIRE_TYPE, t.stringLiteral(contextWireName)));
+            }
+        }
+        else if (isApexWire(resourceName)) {
+            funcObjProps.push(t.objectProperty(shared_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(shared_1.ERROR_PREFIX + 'WireFunction has invalid input');
+        }
+        const inputObject = adgFunc.input[0];
+        configObjExpr = (0, shared_1.valueToExpression)(generatorState, inputObject, true, types_1.ImportUsageState.wireconfig); // 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([shared_1.ID.CONTEXT], configObjExpr);
+    funcObjProps.push(t.objectProperty(shared_1.ID.FUNC_CONFIG, configFunc));
+    // e.g. in: ['recordId', 'fields']
+    if (inputProps.size) {
+        funcObjProps.push(t.objectProperty(shared_1.ID.FUNC_INPUT, t.arrayExpression(Array.from(inputProps).map((v) => t.stringLiteral(v)))));
+    }
+    return funcObjProps;
+}
+/**
+ * Create imports for the provided priming adapter, and stores then in the GeneratorState
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {PrimingAdapterDefinition} primingAdapterDef the PrimingAdapterDefinition from which to find the Priming
+ * Adapter import name identifiers
+ * @returns {PrimingAdapterImportNames} an object containing the Priming adapter import names (adapter, batch adapter, and reducer)
+ */
+function createPrimingAdapterImports(generatorState, primingAdapterDef) {
+    const adapterLocalName = t.identifier(`i${++generatorState.importAliasSuffix}`);
+    const primingAdapterImportNames = {
+        primingAdapterDef,
+        adapter: adapterLocalName,
+    };
+    // create import for priming adapter and store in generator state
+    // to be appended to statements array for this script.
+    const adapterSpecifier = t.importSpecifier(adapterLocalName, t.identifier(primingAdapterDef.prime.identifier));
+    generatorState.scriptGenState.primingAdapterImportDeclarations.push(t.importDeclaration([adapterSpecifier], t.stringLiteral(primingAdapterDef.prime.importPath)));
+    primingAdapterImportNames.adapter = adapterLocalName;
+    // optionally create imports for batch adapter and reducer.
+    if (primingAdapterDef.batch) {
+        if (primingAdapterDef.batch.prime.importPath ===
+            primingAdapterDef.prime.importPath &&
+            primingAdapterDef.batch.prime.identifier ===
+                primingAdapterDef.prime.identifier) {
+            // Special case where batch adapter uses same priming adapter (e.g. getObjectInfos).
+            // Don't create new import, just reuse local name of non-batch adapter.
+            primingAdapterImportNames.batchAdapter = adapterLocalName;
+        }
+        else {
+            const batchLocalName = t.identifier(`i${++generatorState.importAliasSuffix}`);
+            const batchSpecifier = t.importSpecifier(batchLocalName, t.identifier(primingAdapterDef.batch.prime.identifier));
+            generatorState.scriptGenState.primingAdapterImportDeclarations.push(t.importDeclaration([batchSpecifier], t.stringLiteral(primingAdapterDef.batch.prime.importPath)));
+            primingAdapterImportNames.batchAdapter = batchLocalName;
+        }
+        const reducerLocalName = t.identifier(`i${++generatorState.importAliasSuffix}`);
+        const reducerSpecifier = t.importSpecifier(reducerLocalName, t.identifier(primingAdapterDef.batch.reducer.identifier));
+        generatorState.scriptGenState.primingAdapterImportDeclarations.push(t.importDeclaration([reducerSpecifier], t.stringLiteral(primingAdapterDef.batch.reducer.importPath)));
+        primingAdapterImportNames.reducer = reducerLocalName;
+    }
+    return primingAdapterImportNames;
+}
+/**
+ * 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;
+}
+/**
+ * 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
+ */
+function produceErrorAdgFunction(generatorState, error) {
+    const functionValues = {
+        error: {
+            type: 'PrimitiveValue',
+            value: error instanceof Error
+                ? error.message
+                : shared_1.ERROR_PREFIX + 'Something that is not an error was thrown',
+        },
+    };
+    if (error instanceof Error && error.stack) {
+        functionValues.stack = {
+            type: 'PrimitiveValue',
+            value: error.stack,
+        };
+    }
+    const adgFuncCall = adgToExpression(generatorState, {
+        functions: [
+            {
+                type: 'ErrorFunction',
+                input: [
+                    {
+                        type: 'ObjectValue',
+                        value: functionValues,
+                    },
+                ],
+                reference: {
+                    type: 'Unresolved',
+                    value: '',
+                },
+            },
+        ],
+    });
+    const factoryFuncs = (0, shared_1.getFactoryFuncDeclaration)(generatorState, true);
+    return t.program([
+        t.exportDefaultDeclaration(t.functionDeclaration(null, [shared_1.ID.FACTORY, shared_1.ID.CONTEXT], t.blockStatement([
+            // it is literally impossible for this to be undefined given the adgToExpression call
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            factoryFuncs,
+            t.returnStatement(adgFuncCall),
+        ]))),
+    ]);
+}
+exports.produceErrorAdgFunction = produceErrorAdgFunction;
+//# sourceMappingURL=modGenScript.js.map