@komaci/common-shared 240.1.5 → 242.1.1

package/build/moduleMetadata.js

@@ -0,0 +1,646 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTemplateImport = exports.upliftFakePropsFromTemplate = exports.reconcileDefaultAdg = exports.isImportInvalid = exports.reconcilePrimingAdapater = exports.reconcileWireReference = exports.composeWireFunctionMetadata = exports.addTemplateUsageForAdg = exports.mapExportNamesToAdgs = exports.initalizeAdgMetadata = exports.collectImportMetadataFromAst = exports.getImportTemplateKomaciDocByResourceName = exports.updateAliasForImport = exports.addNewImportFromAst = exports.reconcileImport = exports.reconcileNamespace = exports.traverseAstImports = exports.composeImportMetadata = exports.initializeImportMetdataFromKomaciDocument = exports.initAdgMetadataObject = exports.initModuleMetadataObject = exports.NO_KOMACI_DOC_REF = void 0;
+const allowlistNamespaces_1 = require("./allowlistNamespaces");
+const komaciDocumentIntrospection_1 = require("./komaciDocumentIntrospection");
+const types_1 = require("./types");
+const wires_1 = require("./wires");
+const utils_1 = require("./utils");
+/** not all imports are consumed in a statically analyzable way. when we add their metadata, we use this to ack that the komaciDocImportRef for this import is nil */
+exports.NO_KOMACI_DOC_REF = 'nil';
+/**
+ * establish a base object for module metadata
+ * @returns A structured object for module metadata
+ */
+const initModuleMetadataObject = () => ({
+    importGeneratorIndex: 0,
+    adgGeneratorIndex: 0,
+    importsByNamespace: new Map(),
+    importsByName: new Map(),
+    importIndexReference: new Map(),
+    adgs: new Map(),
+    exports: {},
+    templateKomaciDocMap: {},
+});
+exports.initModuleMetadataObject = initModuleMetadataObject;
+/**
+ * establish an empty object for adg metadata
+ * @param defaultGeneratedName a generated name for this object
+ * @returns an empty metadata object
+ */
+const initAdgMetadataObject = (defaultGeneratedName) => ({
+    defaultGeneratedName,
+    properties: new Map(),
+    functions: [],
+    propertiesUsedInTemplate: new Set(),
+    requiredAdgFactoryFunctions: new Set(),
+    requiredCompositionFactoryFunctions: new Set(),
+    hasSourceFile: false,
+});
+exports.initAdgMetadataObject = initAdgMetadataObject;
+/**
+ * Process import references from komaci document
+ * @param doc the KomaciDocument itself
+ * @param moduleMetadata data structure representing metadata about the module we are working on
+ * @param templateAdgIndex the index of the template adg
+ */
+const initializeImportMetdataFromKomaciDocument = (doc, moduleMetadata, templateAdgIndex) => {
+    const namespaces = doc.imports || [];
+    for (let i = 0; i < namespaces.length; i++) {
+        const importNamespace = namespaces[i];
+        const names = new Set(importNamespace.names);
+        const isSupported = (0, allowlistNamespaces_1.isSupportedNamespace)(importNamespace.resourceName);
+        const namespace = {
+            names,
+            isSupported,
+            resourceName: importNamespace.resourceName,
+            isDefaultSpecifier: names.has('default'),
+            isNamespaceSpecifier: names.has('*'),
+        };
+        moduleMetadata.importsByNamespace.set(importNamespace.resourceName, namespace);
+        for (let j = 0; j < importNamespace.names.length; j++) {
+            const name = importNamespace.names[j];
+            const komaciDocImportRef = `${i}/names/${j}`;
+            const importAlias = moduleMetadata.importsByName.has(name)
+                ? `${name}-${importNamespace.resourceName}`
+                : undefined;
+            (0, exports.composeImportMetadata)(name, importNamespace.resourceName, isSupported, templateAdgIndex !== undefined
+                ? `t${templateAdgIndex}-` + komaciDocImportRef
+                : komaciDocImportRef, // to prevent collision in references
+            moduleMetadata, importAlias);
+        }
+        /*
+         * For imports from other resolvable modules we know that they will always be only a default import.
+         * as such if we see one of these special imports we should snag the component id for this resolvable module
+         */
+        const firstItem = templateAdgIndex !== undefined
+            ? `t${templateAdgIndex}-${i}/names/0`
+            : `${i}/names/0`;
+        const adgImportName = moduleMetadata.importIndexReference.get(firstItem);
+        if (namespace.resourceName.startsWith('@salesforce/komaci') && adgImportName) {
+            // name reference and the object map are built along side eachother so if one exists so does the ohter
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const adgImport = moduleMetadata.importsByName.get(adgImportName);
+            adgImport.componentId = (0, komaciDocumentIntrospection_1.importToComponentId)(namespace.resourceName);
+        }
+    }
+};
+exports.initializeImportMetdataFromKomaciDocument = initializeImportMetdataFromKomaciDocument;
+/**
+ * Update module metadata with information about the given import.
+ * @param name import name
+ * @param resourceName import path
+ * @param isSupported if it's from a valid namespace
+ * @param komaciDocImportRef reference index in komaci document
+ * @param moduleMetadata the metadata object
+ *
+ * @return the import metadata object in case anything needs to be modified
+ */
+const composeImportMetadata = (name, resourceName, isSupported, komaciDocImportRef, moduleMetadata, importAlias) => {
+    const generatorIndex = isSupported
+        ? moduleMetadata.importGeneratorIndex++
+        : moduleMetadata.importGeneratorIndex;
+    let importKey = name;
+    if (importAlias) {
+        importKey = importAlias;
+    }
+    else if (name === 'default') {
+        importKey = `default-${resourceName}`;
+        importAlias = importKey;
+    }
+    else if (name === '*') {
+        importKey = `namespace-${resourceName}`;
+        importAlias = importKey;
+    }
+    let currentImport = {
+        name,
+        komaciDocImportRef,
+        importAlias,
+        generatorAlias: `i${generatorIndex}`,
+        resourceName: resourceName,
+        isFromInternalNamespace: isSupported,
+        isFromSupportedLibrary: (0, allowlistNamespaces_1.isLibraryValid)(resourceName),
+        usedInPriming: false,
+        staticallyAnalyzable: true,
+    };
+    if (allowlistNamespaces_1.isLocalHtmlImportReference.test(resourceName)) {
+        const templateKomaciDoc = getImportTemplateKomaciDocByResourceName(resourceName, moduleMetadata.templateKomaciDocMap);
+        if (templateKomaciDoc) {
+            const templateImport = {
+                ...currentImport,
+                templateKomaciDoc: templateKomaciDoc,
+            };
+            currentImport = templateImport;
+        }
+        else {
+            currentImport.isFromSupportedLibrary = false;
+        }
+    }
+    moduleMetadata.importsByName.set(importKey, currentImport);
+    // no komaci doc ref means import is not referenced in the komaci document but was from the ast
+    if (komaciDocImportRef !== exports.NO_KOMACI_DOC_REF) {
+        moduleMetadata.importIndexReference.set(komaciDocImportRef, importKey);
+    }
+    return currentImport;
+};
+exports.composeImportMetadata = composeImportMetadata;
+/**
+ * collect all the imports for a given ast and then execute a callback with information about the import
+ * @param ast The babel ast
+ * @param cb function to call for acting on import information
+ */
+const traverseAstImports = (ast, cb) => {
+    const program = ast.program;
+    const body = program.body;
+    const importDeclarations = body.filter((currentDec) => currentDec.type === 'ImportDeclaration');
+    importDeclarations.forEach((currentDec) => {
+        const specifiers = currentDec.specifiers;
+        const resourceName = currentDec.source.value;
+        specifiers.forEach((specifier) => {
+            let referencedName;
+            let originalImportName;
+            let lookupName;
+            if ((specifier.type === 'ImportSpecifier' &&
+                (0, utils_1.getFromIdentifierOrStringLiteral)(specifier.local) !==
+                    (0, utils_1.getFromIdentifierOrStringLiteral)(specifier.imported)) ||
+                specifier.type !== 'ImportSpecifier') {
+                referencedName = (0, utils_1.getFromIdentifierOrStringLiteral)(specifier.local);
+                lookupName = referencedName;
+                if (specifier.type === 'ImportSpecifier') {
+                    originalImportName = (0, utils_1.getFromIdentifierOrStringLiteral)(specifier.imported);
+                    lookupName = originalImportName;
+                }
+                else if (specifier.type === 'ImportDefaultSpecifier') {
+                    lookupName = `default-${resourceName}`;
+                    originalImportName = 'default';
+                }
+                else if (specifier.type === 'ImportNamespaceSpecifier') {
+                    lookupName = `namespace-${resourceName}`;
+                    originalImportName = '*';
+                }
+            }
+            else {
+                referencedName = (0, utils_1.getFromIdentifierOrStringLiteral)(specifier.imported);
+                lookupName = referencedName;
+            }
+            cb(lookupName, referencedName, resourceName, originalImportName);
+        });
+    });
+};
+exports.traverseAstImports = traverseAstImports;
+/**
+ * given the name of a resource see if we have information about it. if we don't compose the base object for later reference.
+ * @param resourceName The import path
+ * @param moduleMetadata Metadata about this module
+ * @returns The namespace metadata object
+ */
+const reconcileNamespace = (resourceName, moduleMetadata) => {
+    let namespace = moduleMetadata.importsByNamespace.get(resourceName);
+    if (!namespace) {
+        namespace = {
+            names: new Set(),
+            isSupported: allowlistNamespaces_1.isLocalHtmlImportReference.exec(resourceName)
+                ? (0, allowlistNamespaces_1.isSupportedNamespace)(resourceName)
+                : (0, allowlistNamespaces_1.isNamespaceInternal)((0, allowlistNamespaces_1.getNamespaceFromImport)(resourceName)),
+            resourceName: resourceName,
+            isDefaultSpecifier: false,
+            isNamespaceSpecifier: false,
+        };
+        moduleMetadata.importsByNamespace.set(resourceName, namespace);
+    }
+    return namespace;
+};
+exports.reconcileNamespace = reconcileNamespace;
+/**
+ * When looking for an import if it it doesn't exist and we'd have
+ * to just make it anyway this function will do that for you
+ *
+ * @param name identifier of import you're looking for
+ * @param importPath resource path for the import
+ * @param moduleMetadata module metadata instance
+ * @returns The import metadata for this import (as much as we know)
+ */
+const reconcileImport = (name, importPath, moduleMetadata) => {
+    const existingImport = moduleMetadata.importsByName.get(name);
+    if (existingImport) {
+        return existingImport;
+    }
+    else {
+        const newImport = (0, exports.composeImportMetadata)(name, importPath, (0, allowlistNamespaces_1.isNamespaceInternal)((0, allowlistNamespaces_1.getNamespaceFromImport)(importPath)), exports.NO_KOMACI_DOC_REF, moduleMetadata);
+        const namespace = (0, exports.reconcileNamespace)(importPath, moduleMetadata);
+        namespace.names.add(newImport.name);
+        return newImport;
+    }
+};
+exports.reconcileImport = reconcileImport;
+/**
+ * add a new import that is only found in the ast. sometimes imports are not statically analyzable but we still want to collect info on them so we do this.
+ * @param referencedName the name used to reference this import in code
+ * @param namespace the metadata about the import namespace
+ * @param moduleMetadata the metadata about the module
+ * @param originalImportName (optional) the original name of the import that has been aliases. undefined if no alias.
+ */
+const addNewImportFromAst = (referencedName, namespace, moduleMetadata, originalImportName) => {
+    const importAlias = originalImportName && referencedName !== originalImportName
+        ? referencedName
+        : undefined;
+    const importMetadata = (0, exports.composeImportMetadata)(originalImportName || referencedName, namespace.resourceName, namespace.isSupported, exports.NO_KOMACI_DOC_REF, moduleMetadata, importAlias);
+    importMetadata.staticallyAnalyzable = false;
+    if (originalImportName && referencedName !== originalImportName) {
+        importMetadata.importAlias = referencedName;
+    }
+    moduleMetadata.importsByName.set(referencedName, importMetadata);
+    namespace.names.add(referencedName);
+};
+exports.addNewImportFromAst = addNewImportFromAst;
+/**
+ * Komaci Documents don't keep track of import aliases but sometimes they're referenced in code so we want to makes sure we have them.
+ * @param lookupName the name used as the holdover key tor eference this import
+ * @param referencedName the name used to reference this import in code
+ * @param namespace the import namespace metadata
+ * @param moduleMetadata metadata about this module
+ * @param originalImportName (optional) the original name of the import that has been aliases. undefined if no alias.
+ */
+const updateAliasForImport = (lookupName, referencedName, namespace, moduleMetadata, originalImportName) => {
+    const importMetadata = moduleMetadata.importsByName.get(lookupName);
+    if (originalImportName && referencedName !== originalImportName && importMetadata) {
+        const isDefaultOrNamespace = originalImportName === '*' || originalImportName === 'default';
+        importMetadata.importAlias = referencedName;
+        moduleMetadata.importsByName.set(referencedName, importMetadata);
+        moduleMetadata.importsByName.delete(lookupName);
+        namespace.names.delete(isDefaultOrNamespace ? originalImportName : lookupName);
+        namespace.names.add(referencedName);
+        if (importMetadata.komaciDocImportRef !== exports.NO_KOMACI_DOC_REF) {
+            moduleMetadata.importIndexReference.set(importMetadata.komaciDocImportRef, referencedName);
+        }
+    }
+};
+exports.updateAliasForImport = updateAliasForImport;
+/**
+ *  Searches the provided tempalte komaci doc map for a document that corresponds to the provided namesapce.
+ * @param resourceName am imports resource name
+ * @param templateKomaciDocMap a map of template komaci docs.
+ */
+function getImportTemplateKomaciDocByResourceName(resourceName, templateKomaciDocMap) {
+    let templateImportKomaciDoc;
+    if (allowlistNamespaces_1.isLocalHtmlImportReference.test(resourceName)) {
+        const segments = (0, utils_1.getFilepathSegments)(resourceName);
+        const moduleName = segments[1].slice(1);
+        if (templateKomaciDocMap && templateKomaciDocMap[moduleName]) {
+            templateImportKomaciDoc = templateKomaciDocMap[moduleName];
+        }
+    }
+    return templateImportKomaciDoc;
+}
+exports.getImportTemplateKomaciDocByResourceName = getImportTemplateKomaciDocByResourceName;
+/**
+ * pull all needful import metadata we can from the ast
+ * for the most part, we can grab data from the komaci document for imports but sometimes
+ * imports are consumed in non statically analyzable ways like inside of a getter or template string
+ * so we need to collect that info seperately
+ *
+ * also, the Komaci Document doesn't maintain the local alias for default or namespaced imports. so if we
+ * have previously collected information about one of these imports from the Komaci Document then we want
+ * to make sure the alias is consumed and the maps properly represent the way the import is consumed.
+ *
+ * @param moduleMetadata metadata data structure to modify
+ * @param ast ast for the given component
+ */
+const collectImportMetadataFromAst = (ast, moduleMetadata) => {
+    (0, exports.traverseAstImports)(ast, (lookupName, referencedName, resourceName, originalImportName) => {
+        const namespace = (0, exports.reconcileNamespace)(resourceName, moduleMetadata);
+        if (!moduleMetadata.importsByName.has(lookupName)) {
+            (0, exports.addNewImportFromAst)(referencedName, namespace, moduleMetadata, originalImportName);
+        }
+        else {
+            (0, exports.updateAliasForImport)(lookupName, referencedName, namespace, moduleMetadata, originalImportName);
+        }
+    });
+};
+exports.collectImportMetadataFromAst = collectImportMetadataFromAst;
+/**
+ * From a given adg, collect as much metadata as possible ONLY from the komaci document
+ *
+ * This would include:
+ * - property initialization (any info we can collect ONLY from the komaci document)
+ * - function initialization
+ * - default generation name setup
+ * @param docAdgIndex the index of the adg in the KomaciDocument
+ * @param doc the KomaciDocument itself
+ * @param moduleMetadata data structure representing metadata about the module we are working on
+ */
+const initalizeAdgMetadata = (docAdgIndex, doc, moduleMetadata, hasSourceFile, isBundle = true) => {
+    (0, komaciDocumentIntrospection_1.traverseParentAdgs)(doc.adgs?.[docAdgIndex], docAdgIndex, doc, moduleMetadata, (adg, index) => {
+        // if we have data for an adg already then we can assume that it's already been processed
+        if (!moduleMetadata.adgs.has(index)) {
+            const functions = adg.functions;
+            const adgMetadata = {
+                hasSourceFile,
+                defaultGeneratedName: `adg${moduleMetadata.adgGeneratorIndex++}`,
+                requiredAdgFactoryFunctions: new Set(),
+                requiredCompositionFactoryFunctions: new Set(),
+                propertiesUsedInTemplate: new Set(),
+                properties: new Map(),
+                functions: [],
+                parentReference: adg.parentClass,
+            };
+            if (isBundle) {
+                adgMetadata.compositions = [];
+            }
+            if (adgMetadata.parentReference?.type === 'ImportReference') {
+                const importName = moduleMetadata.importIndexReference.get(adgMetadata.parentReference.value);
+                const importMetadata = importName
+                    ? moduleMetadata.importsByName.get(importName)
+                    : undefined;
+                if (!importMetadata ||
+                    !importMetadata.isFromInternalNamespace ||
+                    !importMetadata.isFromSupportedLibrary) {
+                    adgMetadata.parentReference = {
+                        type: 'Unresolved',
+                        value: '',
+                    };
+                }
+                if (importMetadata) {
+                    importMetadata.usedInPriming = true;
+                }
+            }
+            if (adgMetadata.parentReference?.type === 'Unresolved') {
+                adgMetadata.requiredAdgFactoryFunctions.add(types_1.IdKeys.UNRESOLVED_VALUE);
+            }
+            adgMetadata.requiredAdgFactoryFunctions.add(types_1.IdKeys.ADG_FUNC);
+            moduleMetadata.adgs.set(index, adgMetadata);
+            adgMetadata.properties = (0, komaciDocumentIntrospection_1.initializePropertiesMap)(adg.properties, functions, index, doc, moduleMetadata, adgMetadata.properties);
+            (0, komaciDocumentIntrospection_1.processFreestandingFunctions)(functions, adgMetadata, moduleMetadata);
+            adg.functions
+                ?.filter((func) => func.type === types_1.FunctionTypes.WIRE_FUNCTION && func.input)
+                // we've filtered out functions where the input isn't defined already
+                .forEach((func) => 
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            (0, komaciDocumentIntrospection_1.traverseInput)(func.input, (value) => {
+                if (value.type === 'PropertyReference' &&
+                    adgMetadata.properties.has(value.value)) {
+                    const property = adgMetadata.properties.get(value.value);
+                    if (property) {
+                        property.usedInPriming = true;
+                    }
+                }
+                else if (value.type === 'Unresolved') {
+                    adgMetadata.requiredAdgFactoryFunctions.add(types_1.IdKeys.UNRESOLVED_VALUE);
+                }
+                else if (value.type === 'ImportReference' &&
+                    moduleMetadata.importIndexReference.has(value.value)) {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    const importMetadata = moduleMetadata.importsByName.get(
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    moduleMetadata.importIndexReference.get(value.value));
+                    importMetadata.usedInPriming = true;
+                    if (!importMetadata.isFromInternalNamespace) {
+                        adgMetadata.requiredAdgFactoryFunctions.add(types_1.IdKeys.UNRESOLVED_VALUE);
+                        const undefinedValue = value;
+                        undefinedValue.type = 'Unresolved';
+                        undefinedValue.value = types_1.IdKeys.UNRESOLVED_VALUE;
+                    }
+                }
+                return false;
+            }));
+        }
+    });
+};
+exports.initalizeAdgMetadata = initalizeAdgMetadata;
+/**
+ * Update exports key in module metadata mapping the export name to associated adg object
+ * @param doc the KomaciDocument itself
+ * @param moduleMetadata data structure representing metadata about the module we are working on
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const mapExportNamesToAdgs = (exports, moduleMetadata) => {
+    if (exports) {
+        Object.entries(exports).forEach(([exportName, exportReference]) => {
+            if (exportReference?.type === 'AdgReference') {
+                const adg = moduleMetadata.adgs.get(exportReference.value);
+                if (adg) {
+                    adg.exportName = exportName;
+                    moduleMetadata.exports[exportName] = adg;
+                }
+            }
+        });
+    }
+};
+exports.mapExportNamesToAdgs = mapExportNamesToAdgs;
+/**
+ * Walk the compositions to see what props are being used, add this information to the adg metadata
+ * @param doc the template KomaciDocument
+ * @param adgIndex the index of the default adg
+ * @param moduleMetadata data structure representing metadata about the module we are working on
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const addTemplateUsageForAdg = (doc, adgIndex, moduleMetadata) => {
+    if (moduleMetadata.adgs.has(adgIndex)) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const adg = moduleMetadata.adgs.get(adgIndex);
+        if (doc?.exports?.default?.type === 'CompositionReference' &&
+            doc.compositions?.[doc.exports.default.value]) {
+            const composition = doc.compositions[doc.exports.default.value];
+            adg.compositions = [composition];
+            (0, komaciDocumentIntrospection_1.traverseComposition)(composition, (comp, iterationContext) => {
+                (0, komaciDocumentIntrospection_1.updatePropertiesForComposition)(comp, adg.properties, adg.propertiesUsedInTemplate, iterationContext);
+                if (comp && comp.isActive) {
+                    adg.requiredCompositionFactoryFunctions.add(types_1.IdKeys.UNRESOLVED_FUNC);
+                }
+                if ((0, komaciDocumentIntrospection_1.isCompositionAComposedAdg)(comp)) {
+                    adg.requiredCompositionFactoryFunctions.add(types_1.IdKeys.COMPOSED_GRAPH_FUNC);
+                    if (comp.input.type === 'ImportReference') {
+                        const visitedImportForTemplate = comp.input.value.startsWith(`t${adgIndex}`);
+                        const importName = moduleMetadata.importIndexReference.get(visitedImportForTemplate
+                            ? comp.input.value
+                            : `t${adgIndex}-${comp.input.value}`);
+                        const importInfo = importName
+                            ? moduleMetadata.importsByName.get(importName)
+                            : undefined;
+                        if (importInfo) {
+                            importInfo.usedInPriming = true;
+                        }
+                        //changing the comp node to be what t is referencing
+                        if (!visitedImportForTemplate) {
+                            comp.input.value = `t${adgIndex}-${comp.input.value}`;
+                        }
+                    }
+                }
+                else if ((0, komaciDocumentIntrospection_1.isCompositionASlot)(comp)) {
+                    adg.requiredCompositionFactoryFunctions.add(types_1.IdKeys.SLOT_FUNC);
+                }
+                else if ((0, komaciDocumentIntrospection_1.isCompositionAnIteration)(comp)) {
+                    adg.requiredCompositionFactoryFunctions.add(types_1.IdKeys.ITERATION_FUNC);
+                }
+                else if ((0, komaciDocumentIntrospection_1.isCompositionAnImage)(comp)) {
+                    adg.requiredCompositionFactoryFunctions.add(types_1.IdKeys.IMG_FUNC);
+                }
+                else if ((0, komaciDocumentIntrospection_1.isCompositionAContainer)(comp) && (comp.key || comp.slot)) {
+                    adg.requiredCompositionFactoryFunctions.add(types_1.IdKeys.ELEMENT_FUNC);
+                }
+                return false;
+            });
+        }
+    }
+};
+exports.addTemplateUsageForAdg = addTemplateUsageForAdg;
+/**
+ * Collect functional metadata for a wire this includes
+ * - wire function details (name, batch / reducer if priming function)
+ * - input
+ * - required properties
+ *
+ * all bundled up into one readily available package for later composition
+ *
+ * @param functionDetails
+ * @param wireImport
+ * @param moduleMetadata
+ * @returns
+ */
+const composeWireFunctionMetadata = (functionDetails, wireImport, moduleMetadata) => {
+    const isSupported = (0, wires_1.isSupportedWireAdapter)(wireImport.resourceName, wireImport.name);
+    const functionMetadata = {
+        input: functionDetails.input,
+        type: types_1.FunctionTypes.WIRE_FUNCTION,
+        requiredProperties: [],
+        importReference: {
+            functionName: isSupported
+                ? wireImport.importAlias || wireImport.name
+                : types_1.IdKeys.UNRESOLVED_VALUE,
+        },
+    };
+    // compose required properties
+    if (functionDetails.input && functionDetails.input.length > 0) {
+        if (functionDetails.input.length !== 1 ||
+            functionDetails.input[0].type !== 'ObjectValue') {
+            // Only valid input according to Wire Adapter Protocol.
+            throw new Error(types_1.ERROR_PREFIX + 'WireFunction has invalid input');
+        }
+        const inputObject = functionDetails.input[0];
+        functionMetadata.requiredProperties = Object.values(inputObject.value)
+            .filter(komaciDocumentIntrospection_1.isValueProperty)
+            .map((input) => (0, komaciDocumentIntrospection_1.stripChildReferenceFromValue)(input.value));
+    }
+    const primingAdapterDef = (0, wires_1.getPrimingAdapter)(wireImport.resourceName, wireImport.name);
+    if (primingAdapterDef) {
+        (0, exports.reconcilePrimingAdapater)(functionMetadata, primingAdapterDef, moduleMetadata);
+        functionMetadata.type = types_1.FunctionTypes.PRIMING_FUNCTION;
+        wireImport.usedInPriming = false;
+    }
+    else {
+        wireImport.usedInPriming = isSupported;
+    }
+    return functionMetadata;
+};
+exports.composeWireFunctionMetadata = composeWireFunctionMetadata;
+/**
+ * A Wire Function can only have one valid type of reference, an import. if we see an import we should collect the info for that
+ * otherwise, we should mark the reference as unresolved and make sure we are accounting for it in factory functions
+ * @param func The details about a function from the komaci doc
+ * @param adg metadata about the adg this function is in
+ * @param moduleMetadata general module metadata (imports mostly)
+ * @returns import metadata if this wire references a valid one, undefined otherwise
+ */
+const reconcileWireReference = (func, adg, moduleMetadata) => {
+    let importMetadata;
+    if (func.reference.type === 'ImportReference' &&
+        moduleMetadata.importIndexReference.has(func?.reference.value) &&
+        moduleMetadata.importsByName.has(
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        moduleMetadata.importIndexReference.get(func?.reference.value))) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        importMetadata = moduleMetadata.importsByName.get(
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        moduleMetadata.importIndexReference.get(func?.reference.value));
+    }
+    else {
+        func.reference = {
+            type: 'Unresolved',
+            value: '',
+        };
+        adg.requiredAdgFactoryFunctions.add(types_1.IdKeys.UNRESOLVED_VALUE);
+    }
+    return importMetadata;
+};
+exports.reconcileWireReference = reconcileWireReference;
+/**
+ * Some wires have associated priming adapters. if we do have one of those then we want to use it instead of the
+ * original wire adapter referenced in the komaci document. as part of this we have to make sure the new imports
+ * are made and appropriately referenced inside module metadata
+ *
+ * @param functionMetadata Details about a wire function
+ * @param primingAdapterDef Details about the priming adapter associated for this wire
+ * @param moduleMetadata Instance of module metadata data structure
+ */
+const reconcilePrimingAdapater = (functionMetadata, primingAdapterDef, moduleMetadata) => {
+    const importMetadata = (0, exports.reconcileImport)(primingAdapterDef.prime.identifier, primingAdapterDef.prime.importPath, moduleMetadata);
+    importMetadata.usedInPriming = true;
+    functionMetadata.importReference.functionName = importMetadata.name;
+    if (primingAdapterDef.batch) {
+        if (primingAdapterDef.batch.prime.importPath ===
+            primingAdapterDef.prime.importPath &&
+            primingAdapterDef.batch.prime.identifier ===
+                primingAdapterDef.prime.identifier) {
+            functionMetadata.importReference.batchingName = importMetadata.name;
+        }
+        else {
+            const batchImport = (0, exports.reconcileImport)(primingAdapterDef.batch.prime.identifier, primingAdapterDef.batch.prime.importPath, moduleMetadata);
+            batchImport.usedInPriming = true;
+            functionMetadata.importReference.batchingName = batchImport.name;
+        }
+        const reducerImport = (0, exports.reconcileImport)(primingAdapterDef.batch.reducer.identifier, primingAdapterDef.batch.reducer.importPath, moduleMetadata);
+        reducerImport.usedInPriming = true;
+        functionMetadata.importReference.reducer = reducerImport.name;
+    }
+};
+exports.reconcilePrimingAdapater = reconcilePrimingAdapater;
+function isImportInvalid(importMetadata) {
+    return (!importMetadata.isFromInternalNamespace || !importMetadata.isFromSupportedLibrary);
+}
+exports.isImportInvalid = isImportInvalid;
+/**
+ * in specific cases, mainly template only compositions, we may not have a default adg already but need one to compose the resolvable module.
+ * @param currentDefaultAdgIndex The current index of the default adg if it exists
+ * @param moduleMetadata metadata about the module
+ * @returns the index of the default adg
+ */
+function reconcileDefaultAdg(currentDefaultAdgIndex, moduleMetadata) {
+    let componentDefaultAdgIndex = currentDefaultAdgIndex;
+    if (componentDefaultAdgIndex === undefined && moduleMetadata.adgs.size === 0) {
+        componentDefaultAdgIndex = moduleMetadata.adgGeneratorIndex++;
+        const fakeDefaultAdg = (0, exports.initAdgMetadataObject)(`adg${componentDefaultAdgIndex}`);
+        fakeDefaultAdg.requiredAdgFactoryFunctions.add(types_1.IdKeys.ADG_FUNC);
+        moduleMetadata.adgs.set(componentDefaultAdgIndex, fakeDefaultAdg);
+        moduleMetadata.exports.default = fakeDefaultAdg;
+    }
+    return componentDefaultAdgIndex;
+}
+exports.reconcileDefaultAdg = reconcileDefaultAdg;
+/**
+ * If we process a template and see it has some props we don't know about we can uplift them to the adgs props using this.
+ * this is only currently used for template only bundles
+ * @param adg The metadata object for a given adg
+ */
+function upliftFakePropsFromTemplate(adg) {
+    for (const prop of adg?.propertiesUsedInTemplate.values()) {
+        if (!adg.properties.has(prop)) {
+            adg.properties.set(prop, {
+                type: types_1.PropertyTypes.BASE,
+                isPublic: true,
+                usedInPriming: true,
+            });
+        }
+    }
+}
+exports.upliftFakePropsFromTemplate = upliftFakePropsFromTemplate;
+/**
+ * Helper function to determine if an importMetadata object is an instance of a TemplateImportMetadata
+ * @param importMetadata the import metadata object
+ * @returns true or false;
+ */
+function isTemplateImport(importMetadata) {
+    const temp = importMetadata.templateKomaciDoc;
+    return temp != undefined;
+}
+exports.isTemplateImport = isTemplateImport;
+//# sourceMappingURL=moduleMetadata.js.map