@komaci/common-shared 240.1.3 → 242.1.0

package/build/komaciDocumentIntrospection.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPropertyFromImport = exports.isPropertyAWire = exports.updatePropertyUsage = exports.updatePropertyMetadataFromTemplateDoc = exports.updatePropertiesForComposition = exports.collectPropertyMetadataFromScriptDoc = exports.traverseParentAdgs = exports.traverseInput = exports.initializePropertiesMap = exports.stripChildReferenceFromValue = exports.isImportValid = exports.isAFunctionOfType = exports.isFunctionReference = exports.isSrcABinding = exports.isSrcPrimitiveValue = exports.isCompositionAnImage = exports.isCompositionAComposedAdg = exports.isCompositionAnIteration = void 0;
+exports.importToComponentId = exports.isPropertyFromImport = exports.updatePropertyUsage = exports.updatePropertiesForComposition = exports.traverseComposition = exports.doesAdgExist = exports.traverseParentAdgs = exports.traverseInput = exports.processFreestandingFunctions = exports.initializePropertiesMap = exports.stripChildReferenceFromValue = exports.isImportValid = exports.isAFunctionOfType = exports.isValueProperty = exports.isFunctionReference = exports.isSrcABinding = exports.isSrcPrimitiveValue = exports.isCompositionAnImage = exports.isCompositionAComposedAdg = exports.isCompositionAContainer = exports.isCompositionASlot = exports.isCompositionAnIteration = void 0;
 const types_1 = require("./types");
+const moduleMetadata_1 = require("./moduleMetadata");
 /**
  * Check if the composition is an Iteration
  * @param composition composition obj to check
@@ -11,6 +12,24 @@ function isCompositionAnIteration(composition) {
     return composition?.type === 'Iteration';
 }
 exports.isCompositionAnIteration = isCompositionAnIteration;
+/**
+ * Check if the composition is a Slot
+ * @param composition composition obj to check
+ * @returns if composition is a Slot
+ */
+function isCompositionASlot(composition) {
+    return composition?.type === 'Slot';
+}
+exports.isCompositionASlot = isCompositionASlot;
+/**
+ * Check if the composition is an Iteration
+ * @param composition composition obj to check
+ * @returns if composition is an Iteration
+ */
+function isCompositionAContainer(composition) {
+    return composition?.type === 'Container';
+}
+exports.isCompositionAContainer = isCompositionAContainer;
 /**
  * Check if the composition is a ComposedAdg
  * @param composition composition obj to check
@@ -56,6 +75,15 @@ function isFunctionReference(node) {
     return node?.type === 'FunctionReference';
 }
 exports.isFunctionReference = isFunctionReference;
+/**
+ * Check if input is a property reference
+ * @param node input to check
+ * @returns if it is a property reference
+ */
+function isValueProperty(node) {
+    return node?.type === 'PropertyReference';
+}
+exports.isValueProperty = isValueProperty;
 /**
  * Confirm if a function object is of a specfic type
  * @param type The type to validate against
@@ -104,78 +132,142 @@ exports.stripChildReferenceFromValue = stripChildReferenceFromValue;
  *
  * @param component The component ADG to process
  * @param doc The full komaci doc we are looking in
+ * @param moduleMetadata Data structure of metadata about the component we are analyzing
  * @returns The inflated properties map
  */
-function initializePropertiesMap(component, doc, properties) {
-    if (component.properties) {
-        for (const [name, detail] of Object.entries(component.properties)) {
+function initializePropertiesMap(adgProperties, adgFunctions, adgIndex, doc, moduleMetadata, properties = new Map()) {
+    const adgMetadata = moduleMetadata.adgs.get(adgIndex);
+    if (adgMetadata && adgProperties) {
+        for (const [name, detail] of Object.entries(adgProperties)) {
             const property = {
                 usedInPriming: false,
-                type: types_1.PropertyTypes.INTERNAL,
+                type: types_1.PropertyTypes.BASE,
+                isPublic: false,
+                fromAdg: adgIndex,
             };
             if (detail.isPublic) {
-                property.type = types_1.PropertyTypes.PUBLIC;
+                property.isPublic = true;
             }
-            else if (isAFunctionOfType('WireFunction', detail, component.functions) &&
-                doc.imports) {
+            else if (isAFunctionOfType('WireFunction', detail, adgFunctions)) {
                 //ts rules and this is how types work ig
-                const functionDetail = component.functions?.[detail.input.value];
+                const functionDetail = adgFunctions?.[detail.input.value];
                 if (functionDetail) {
-                    const importIndex = parseInt(functionDetail.reference.value.charAt(0));
-                    const nameIndex = parseInt(functionDetail?.reference.value.charAt(functionDetail?.reference.value.length - 1));
-                    if (isImportValid(importIndex, nameIndex, doc.imports)) {
-                        property.type = types_1.PropertyTypes.WIRE;
-                        property.usedInPriming = true;
-                        property.wire = {
-                            name: doc.imports[importIndex].names[nameIndex],
-                            resourceName: doc.imports[importIndex].resourceName,
-                            komaciDocImportRef: functionDetail.reference.value,
-                        };
+                    functionDetail.visited = true;
+                    const wireImport = (0, moduleMetadata_1.reconcileWireReference)(functionDetail, adgMetadata, moduleMetadata);
+                    property.type = types_1.PropertyTypes.WIRE;
+                    if (wireImport) {
+                        const wireFunction = (0, moduleMetadata_1.composeWireFunctionMetadata)(functionDetail, wireImport, moduleMetadata);
+                        const isFunctionUnsupported = wireFunction.importReference.functionName ===
+                            types_1.IdKeys.UNRESOLVED_VALUE;
+                        if (isFunctionUnsupported) {
+                            adgMetadata.requiredAdgFactoryFunctions.add(types_1.IdKeys.UNRESOLVED_VALUE);
+                            property.functionIndex =
+                                types_1.UNSUPPORTED_FUNCTION;
+                        }
+                        else {
+                            const functionsLength = adgMetadata.functions.push(wireFunction);
+                            property.functionIndex =
+                                functionsLength - 1;
+                        }
+                    }
+                    else {
+                        property.functionIndex =
+                            types_1.UNSUPPORTED_FUNCTION;
                     }
                 }
             }
-            if (detail.initial?.type === 'ImportReference' && doc.imports) {
-                const importIndex = parseInt(detail.initial.value.charAt(0));
-                const nameIndex = parseInt(detail.initial.value.charAt(detail.initial.value.length - 1));
-                if (isImportValid(importIndex, nameIndex, doc.imports)) {
-                    property.imports = {
-                        [detail.initial.value]: {
-                            name: doc.imports[importIndex].names[nameIndex],
-                            resourceName: doc.imports[importIndex].resourceName,
-                            komaciDocImportRef: detail.initial.value,
-                        },
-                    };
+            if (!adgMetadata.hasSourceFile &&
+                detail.input?.type === 'ImportReference' &&
+                moduleMetadata.importIndexReference.has(detail.input.value) &&
+                moduleMetadata.importsByName.has(
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                moduleMetadata.importIndexReference.get(detail.input.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(detail.input.value));
+                if (!importMetadata.isFromInternalNamespace ||
+                    !importMetadata.isFromSupportedLibrary) {
+                    property.type = types_1.PropertyTypes.GETTER;
+                    adgMetadata.requiredAdgFactoryFunctions.add(types_1.IdKeys.UNRESOLVED_VALUE);
+                    property.functionIndex =
+                        types_1.UNSUPPORTED_FUNCTION;
+                }
+                else {
+                    detail.initial = detail.input;
                 }
             }
-            else if (detail.initial && doc.imports) {
-                const imports = {};
-                let totalImportRefs = 0;
+            else if (!adgMetadata.hasSourceFile &&
+                detail.input?.type === 'Unresolved') {
+                property.type = types_1.PropertyTypes.GETTER;
+                adgMetadata.requiredAdgFactoryFunctions.add(types_1.IdKeys.UNRESOLVED_VALUE);
+                property.functionIndex =
+                    types_1.UNSUPPORTED_FUNCTION;
+            }
+            if (detail.initial?.type === 'ImportReference' &&
+                moduleMetadata.importIndexReference.has(detail.initial.value) &&
+                moduleMetadata.importsByName.has(
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                moduleMetadata.importIndexReference.get(detail.initial.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(detail.initial.value));
+                importMetadata.usedInPriming = true;
+                property.inital = detail.initial;
+            }
+            else if (detail.initial) {
                 traverseInput(detail.initial, (potentialImportRef) => {
-                    if (potentialImportRef.type === 'ImportReference') {
-                        totalImportRefs++;
-                        const importIndex = parseInt(potentialImportRef.value.charAt(0));
-                        const nameIndex = parseInt(potentialImportRef.value.charAt(potentialImportRef.value.length - 1));
-                        if (doc.imports &&
-                            isImportValid(importIndex, nameIndex, doc.imports)) {
-                            imports[potentialImportRef.value] = {
-                                name: doc.imports[importIndex].names[nameIndex],
-                                resourceName: doc.imports[importIndex].resourceName,
-                                komaciDocImportRef: potentialImportRef.value,
-                            };
-                        }
+                    if (potentialImportRef.type === 'ImportReference' &&
+                        moduleMetadata.importIndexReference.has(potentialImportRef.value) &&
+                        moduleMetadata.importsByName.has(
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        moduleMetadata.importIndexReference.get(potentialImportRef.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(potentialImportRef.value));
+                        importMetadata.usedInPriming = true;
+                    }
+                    else if (potentialImportRef.type === 'Unresolved') {
+                        adgMetadata.requiredAdgFactoryFunctions.add(types_1.IdKeys.UNRESOLVED_VALUE);
                     }
                     return false;
                 });
-                if (totalImportRefs !== 0) {
-                    property.imports = imports;
-                }
+                property.inital = detail.initial;
             }
             properties.set(name, property);
         }
+        adgMetadata.properties = properties;
     }
     return properties;
 }
 exports.initializePropertiesMap = initializePropertiesMap;
+/**
+ * run over functions not associated with a property and make sure we collect info about the good ones
+ * @param functions list of functions for a given adg
+ * @param adg metadata about the given adg
+ * @param moduleMetadata general module metadata
+ */
+function processFreestandingFunctions(functions = [], adg, moduleMetadata) {
+    for (let i = 0; i < functions.length; i++) {
+        const unprocessedFunction = functions[i];
+        if (!unprocessedFunction.visited && unprocessedFunction.type === 'WireFunction') {
+            const wireImport = (0, moduleMetadata_1.reconcileWireReference)(unprocessedFunction, adg, moduleMetadata);
+            if (wireImport) {
+                const wireFunction = (0, moduleMetadata_1.composeWireFunctionMetadata)(unprocessedFunction, wireImport, moduleMetadata);
+                const isFunctionUnsupported = wireFunction.importReference.functionName === types_1.IdKeys.UNRESOLVED_VALUE;
+                if (isFunctionUnsupported) {
+                    adg.requiredAdgFactoryFunctions.add(types_1.IdKeys.UNRESOLVED_VALUE);
+                }
+                else {
+                    adg.functions.push(wireFunction);
+                }
+            }
+        }
+    }
+}
+exports.processFreestandingFunctions = processFreestandingFunctions;
 /**
  * Traverse the input of a Function object (as definged in a Komaci Document) generically. When we get to a specific value
  * in the tree, we run the provided callback. The callback can return `true` if we should stop
@@ -189,6 +281,9 @@ exports.initializePropertiesMap = initializePropertiesMap;
  */
 function traverseInput(input, cb, key) {
     let shouldEarlyExit = false;
+    if (!input) {
+        return false;
+    }
     if (!Array.isArray(input) &&
         !(input.type === 'ArrayValue' || input.type === 'ObjectValue')) {
         shouldEarlyExit = cb(input, key);
@@ -219,51 +314,21 @@ function traverseInput(input, cb, key) {
     return shouldEarlyExit;
 }
 exports.traverseInput = traverseInput;
-function traverseParentAdgs(component, doc, cb) {
-    if (component.parentClass &&
-        component.parentClass.type === 'AdgReference' &&
-        doc.adgs?.[component.parentClass.value]) {
-        traverseParentAdgs(doc.adgs?.[component.parentClass.value], doc, cb);
+function traverseParentAdgs(component, komaciDocIndex, doc, moduleMetadata, cb) {
+    if (component) {
+        if (component.parentClass &&
+            component.parentClass.type === 'AdgReference' &&
+            (0, exports.doesAdgExist)(component.parentClass.value, doc)) {
+            traverseParentAdgs(doc.adgs?.[component.parentClass.value], component.parentClass.value, doc, moduleMetadata, cb);
+        }
+        cb(component, komaciDocIndex);
     }
-    cb(component);
 }
 exports.traverseParentAdgs = traverseParentAdgs;
-/**
- * Traverse the Komaci Document for a script file and collect property usages.
- *
- * This function:
- * 1. prepares the properties object with initial values
- * 2. collects usages of properties from wire functions
- * @param doc Komaci Script Doc to traverse
- * @returns contextual information about properties
- */
-function collectPropertyMetadataFromScriptDoc(doc) {
-    if (doc?.exports?.default?.type === 'AdgReference' &&
-        doc?.adgs?.[doc.exports?.default?.value]) {
-        const component = doc.adgs[doc.exports.default.value];
-        let properties = new Map();
-        traverseParentAdgs(component, doc, (currentComponent) => {
-            properties = initializePropertiesMap(currentComponent, doc, properties);
-            for (const functionDetail of currentComponent.functions || []) {
-                if (functionDetail.type === 'WireFunction' && functionDetail.input) {
-                    traverseInput(functionDetail.input, (value) => {
-                        if (value.type === 'PropertyReference' &&
-                            properties.has(value.value)) {
-                            const property = properties.get(value.value);
-                            if (property) {
-                                property.usedInPriming = true;
-                            }
-                        }
-                        return false;
-                    });
-                }
-            }
-        });
-        return properties;
-    }
-    return new Map();
-}
-exports.collectPropertyMetadataFromScriptDoc = collectPropertyMetadataFromScriptDoc;
+const doesAdgExist = (index, doc) => {
+    return doc.adgs?.[index] !== undefined;
+};
+exports.doesAdgExist = doesAdgExist;
 /**
  * Helper to clean up a potential property, see if it exists and update if it does
  * @param value potential property. could be in the form of record/data/whatever
@@ -279,62 +344,77 @@ function updatePropertyIfExists(value, properties, key) {
             [key]: true,
         });
     }
+    return cleanedUpValue;
 }
+/**
+ * Traverse through a composition looking for something
+ * @param composition the composition to look at
+ * @param cb the function to run on every new composition. returning true here will end traversal for that subtree
+ */
+function traverseComposition(composition, cb, iteratorContext = []) {
+    const found = cb(composition, iteratorContext);
+    if (!found && composition && composition.compositions) {
+        for (const value of composition.compositions) {
+            if (isCompositionAnIteration(composition)) {
+                iteratorContext.unshift(composition.iterator);
+            }
+            traverseComposition(value, cb, iteratorContext);
+            if (isCompositionAnIteration(composition)) {
+                iteratorContext.shift();
+            }
+        }
+    }
+}
+exports.traverseComposition = traverseComposition;
 /**
  * Recursively probe a composition and it's children for usages of properties.
  * @param composition Current composition
  * @param properties The map of properties to update
  */
-function updatePropertiesForComposition(composition, properties) {
+function updatePropertiesForComposition(composition, properties, propertiesUsedInTemplate, iterationContext) {
     if (composition && composition.key) {
         const container = composition;
         if (container.key && container.key.type === 'Binding') {
-            updatePropertyIfExists(container.key.value, properties, 'usedInPriming');
+            const prop = updatePropertyIfExists(container.key.value, properties, 'usedInPriming');
+            if (!iterationContext.includes(prop)) {
+                propertiesUsedInTemplate.add(prop);
+            }
         }
     }
     if (composition && composition.isActive) {
-        updatePropertyIfExists(composition.isActive.input.value, properties, 'usedInPriming');
+        const prop = updatePropertyIfExists(composition.isActive.input.value, properties, 'usedInPriming');
+        if (!iterationContext.includes(prop)) {
+            propertiesUsedInTemplate.add(prop);
+        }
     }
     if (isCompositionAnIteration(composition)) {
-        updatePropertyIfExists(composition.input.value, properties, 'usedInPriming');
+        const prop = updatePropertyIfExists(composition.input.value, properties, 'usedInPriming');
+        if (!iterationContext.includes(prop)) {
+            propertiesUsedInTemplate.add(prop);
+        }
     }
     if (isCompositionAComposedAdg(composition) && composition.properties) {
         for (const property of Object.values(composition.properties || {})) {
             if (property.type === 'Binding') {
-                updatePropertyIfExists(property.value, properties, 'usedInPriming');
+                const prop = updatePropertyIfExists(property.value, properties, 'usedInPriming');
+                if (!iterationContext.includes(prop)) {
+                    propertiesUsedInTemplate.add(prop);
+                }
             }
         }
-        if (composition.input.type === 'Binding') {
-            updatePropertyIfExists(composition.input.value, properties, 'usedInPriming');
-        }
     }
     if (isCompositionAnImage(composition)) {
         // if img.src is a Binding, then let's update the property to note it is used in Priming
         if (isSrcABinding(composition.src)) {
             const binding = composition.src;
-            updatePropertyIfExists(binding.value, properties, 'usedInPriming');
-        }
-    }
-    if (composition && composition.compositions) {
-        for (const value of composition.compositions) {
-            updatePropertiesForComposition(value, properties);
+            const prop = updatePropertyIfExists(binding.value, properties, 'usedInPriming');
+            if (!iterationContext.includes(prop)) {
+                propertiesUsedInTemplate.add(prop);
+            }
         }
     }
 }
 exports.updatePropertiesForComposition = updatePropertiesForComposition;
-/**
- * Collect usages of properties from compositions in a Komaci Template Document
- * @param doc Komaci Document
- * @param properties The current map of properties, this is just updating them.
- */
-function updatePropertyMetadataFromTemplateDoc(doc, properties) {
-    if (doc?.exports?.default?.type === 'CompositionReference' &&
-        doc.compositions?.[doc.exports.default.value]) {
-        const composition = doc.compositions[doc.exports.default.value];
-        updatePropertiesForComposition(composition, properties);
-    }
-}
-exports.updatePropertyMetadataFromTemplateDoc = updatePropertyMetadataFromTemplateDoc;
 /**
  * Updates used properties to record whether they were used in Priming.
  * @param prop the name of the getter under consideration
@@ -355,12 +435,35 @@ function updatePropertyUsage(prop, identifiers, properties, type) {
     });
 }
 exports.updatePropertyUsage = updatePropertyUsage;
-function isPropertyAWire(property) {
-    return property.type === types_1.PropertyTypes.WIRE;
-}
-exports.isPropertyAWire = isPropertyAWire;
 function isPropertyFromImport(property) {
     return property.imports !== undefined;
 }
 exports.isPropertyFromImport = isPropertyFromImport;
+/**
+ * Convers an import in a Komaci template doc to a component identifier.
+ * Example:
+ * From: @salesforce/komaci/c__child1__child1.js
+ * To: c-child1
+ * @param {string} resourceName the import path
+ * @returns {string} a string representing the component id generated from the import resource name
+ */
+function importToComponentId(resourceName) {
+    // First split by '/' and confirm expected # segments.
+    let segments = resourceName.split('/');
+    if (segments.length !== 3) {
+        throw new Error(types_1.ERROR_PREFIX + 'komaciDoc contains invalid import');
+    }
+    // Now split last segment by '__' and confirm expected # segments.
+    segments = segments[2].split('__');
+    if (segments.length !== 3) {
+        throw new Error(types_1.ERROR_PREFIX + 'komaciDoc contains invalid import');
+    }
+    const namespace = segments[0];
+    // name converted from camel case to kebab case.
+    const name = segments[1]
+        .replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, '$1-$2')
+        .toLowerCase();
+    return `${namespace}-${name}`;
+}
+exports.importToComponentId = importToComponentId;
 //# sourceMappingURL=komaciDocumentIntrospection.js.map

package/build/moduleMetadata.d.ts

@@ -0,0 +1,160 @@
+import { FunctionType, KomaciDocument } from '@komaci/types';
+import * as t from '@babel/types';
+import { AdgMetadata, ImportDetail, ImportMetadata, ModuleMetadata, PrimingAdapterDefinition, WireFunctionMetadata } from './types';
+/** 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 */
+export declare const NO_KOMACI_DOC_REF = "nil";
+/**
+ * establish a base object for module metadata
+ * @returns A structured object for module metadata
+ */
+export declare const initModuleMetadataObject: () => ModuleMetadata;
+/**
+ * establish an empty object for adg metadata
+ * @param defaultGeneratedName a generated name for this object
+ * @returns an empty metadata object
+ */
+export declare const initAdgMetadataObject: (defaultGeneratedName: string) => AdgMetadata;
+/**
+ * Process import references from komaci document
+ * @param doc the KomaciDocument itself
+ * @param moduleMetadata data structure representing metadata about the module we are working on
+ */
+export declare const initializeImportMetdataFromKomaciDocument: (doc: KomaciDocument, moduleMetadata: ModuleMetadata, fromTemplate?: boolean) => void;
+/**
+ * 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
+ */
+export declare const composeImportMetadata: (name: string, resourceName: string, isSupported: boolean, komaciDocImportRef: string, moduleMetadata: ModuleMetadata, importAlias?: string) => ImportMetadata;
+/**
+ * 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
+ */
+export declare const traverseAstImports: (ast: t.File, cb: (lookupName: string, referencedName: string, resourceName: string, originalImportName?: string) => void) => void;
+/**
+ * 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
+ */
+export declare const reconcileNamespace: (resourceName: string, moduleMetadata: ModuleMetadata) => ImportDetail;
+/**
+ * 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)
+ */
+export declare const reconcileImport: (name: string, importPath: string, moduleMetadata: ModuleMetadata) => ImportMetadata;
+/**
+ * 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.
+ */
+export declare const addNewImportFromAst: (referencedName: string, namespace: ImportDetail, moduleMetadata: ModuleMetadata, originalImportName?: string) => void;
+/**
+ * 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.
+ */
+export declare const updateAliasForImport: (lookupName: string, referencedName: string, namespace: ImportDetail, moduleMetadata: ModuleMetadata, originalImportName?: string) => void;
+/**
+ * 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
+ */
+export declare const collectImportMetadataFromAst: (ast: t.File, moduleMetadata: ModuleMetadata) => void;
+/**
+ * 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
+ */
+export declare const initalizeAdgMetadata: (docAdgIndex: number, doc: KomaciDocument, moduleMetadata: ModuleMetadata, hasSourceFile: boolean, isBundle?: boolean) => void;
+/**
+ * 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
+ */
+export declare const mapExportNamesToAdgs: (exports: KomaciDocument['exports'], moduleMetadata: ModuleMetadata) => void;
+/**
+ * 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
+ */
+export declare const addTemplateUsageForDefaultAdg: (doc: KomaciDocument, adgIndex: number, moduleMetadata: ModuleMetadata) => void;
+/**
+ * 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
+ */
+export declare const composeWireFunctionMetadata: (functionDetails: FunctionType, wireImport: ImportMetadata, moduleMetadata: ModuleMetadata) => WireFunctionMetadata;
+/**
+ * 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
+ */
+export declare const reconcileWireReference: (func: FunctionType, adg: AdgMetadata, moduleMetadata: ModuleMetadata) => ImportMetadata | undefined;
+/**
+ * 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
+ */
+export declare const reconcilePrimingAdapater: (functionMetadata: WireFunctionMetadata, primingAdapterDef: PrimingAdapterDefinition, moduleMetadata: ModuleMetadata) => void;
+export declare function isImportInvalid(importMetadata: ImportMetadata): boolean;
+/**
+ * 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
+ */
+export declare function reconcileDefaultAdg(currentDefaultAdgIndex: number | undefined, moduleMetadata: ModuleMetadata): number;
+/**
+ * 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
+ */
+export declare function upliftFakePropsFromTemplate(adg: AdgMetadata): void;
+//# sourceMappingURL=moduleMetadata.d.ts.map