@komaci/esm-generator 240.1.3

package/build/shared.js

@@ -0,0 +1,588 @@
+"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.addPropertyFunction = exports.updateKomaciDocumentWithValidTemplatedStrings = exports.sanitizeFunction = exports.mapRealNameToGenerated = exports.hoistTemplateStrings = exports.processTemplateStrings = exports.updateKomaciDocumentWithValidGetters = exports.transformGetters = exports.processGetters = exports.getComponentSrcJs = exports.valueToExpression = exports.bindingRootToExpression = exports.bindingToExpression = exports.primitiveToExpression = exports.getFactoryFuncDeclaration = exports.retrieveImportInfo = exports.updateImportInfoState = exports.ID = exports.PRIMING_FUNCTION = exports.ERROR_FUNCTION = exports.TEMPLATED_STRING_FUNCTION = exports.GETTER_FUNCTION = exports.WIRE_FUNCTION = exports.USER_VARIABLE_PREFIX = exports.UNRESOLVED = exports.ADG_IMPORT_SUFFIX = exports.PROPS = exports.CONTEXT = exports.ERROR_PREFIX = void 0;
+const t = __importStar(require("@babel/types"));
+const types_1 = require("./types");
+const static_analyzer_1 = require("@komaci/static-analyzer");
+const common_shared_1 = require("@komaci/common-shared");
+exports.ERROR_PREFIX = '[komaci esm-generator] ';
+exports.CONTEXT = 'ctx';
+exports.PROPS = 'props';
+exports.ADG_IMPORT_SUFFIX = 'getAdgDefinition';
+exports.UNRESOLVED = 'unresolved';
+exports.USER_VARIABLE_PREFIX = 'user_var_';
+exports.WIRE_FUNCTION = 'WireFunction';
+exports.GETTER_FUNCTION = 'GetterFunction';
+exports.TEMPLATED_STRING_FUNCTION = 'TemplatedStringFunction';
+exports.ERROR_FUNCTION = 'ErrorFunction';
+exports.PRIMING_FUNCTION = 'PrimingFunction';
+exports.ID = {
+    CONTEXT: t.identifier(exports.CONTEXT),
+    PROPS: t.identifier(exports.PROPS),
+    FACTORY: t.identifier('fct'),
+    COMPOSED_GRAPH_FUNC: t.identifier('cg'),
+    ITERATION_FUNC: t.identifier('i'),
+    UNRESOLVED_FUNC: t.identifier('u'),
+    SLOT_FUNC: t.identifier('s'),
+    ELEMENT_FUNC: t.identifier('e'),
+    ADG_FUNC: t.identifier('adg'),
+    SLOT: t.identifier('slot'),
+    COMPONENT_ID: t.identifier('componentId'),
+    UNDEFINED: t.identifier('undefined'),
+    PROP_API: t.identifier('a'),
+    PROP_INIT: t.identifier('i'),
+    PROP_FUNC: t.identifier('f'),
+    PROP_GETTER: t.identifier('g'),
+    DEFAULT_COMP: t.identifier('comp1'),
+    FUNC_ID: t.identifier('f'),
+    FUNC_NAME: t.identifier('fN'),
+    FUNC_TYPE: t.identifier('t'),
+    FUNC_CONFIG: t.identifier('c'),
+    FUNC_INPUT: t.identifier('in'),
+    WIRE_TYPE: t.identifier('wt'),
+    UNRESOLVED_VALUE: t.identifier('unresolved'),
+    BATCH_FUNC_ID: t.identifier('b'),
+    BATCH_FUNC_NAME: t.identifier('bN'),
+    REDUCER_FUNC_ID: t.identifier('r'),
+    IMG_SRC: t.identifier('src'),
+    IMG_FUNC: t.identifier('img'),
+};
+/**
+ * Retrieve info about an import given its reference value (e.g. 0/names/0), while initializing/updating its usageState, as well
+ * as updating required factory functions (if we are returning an ImportInfo for an unsupported namespace).
+ * @param generatorState the GeneratorState
+ * @param importRefValue import reference value, as a string. ex: "0/names/0"
+ * @param isScriptFile boolean indicating whether we are calling the method while processing a Script (JS file)[true], or a template (HTML file)[false]
+ * @param usageState ImportUsageState enum that represents the way the import will be used. Some example values are: composedadg, wireadapter,
+ *        getter, initialvalue, wireconfig, parentadg
+ * @returns ImportInfo object, updated with latest usageState
+ */
+function updateImportInfoState(generatorState, importRefValue, isScriptFile, usageState) {
+    const importInfo = isScriptFile
+        ? generatorState.scriptGenState.importRefsMap[importRefValue]
+        : generatorState.templateGenState.importRefsMap[importRefValue];
+    if (!importInfo) {
+        throw new Error(exports.ERROR_PREFIX + 'komaciDoc contains invalid import reference');
+    }
+    if (isScriptFile) {
+        importInfo.importUsages.add(usageState);
+        if (usageState === types_1.ImportUsageState.wireadapter) {
+            generatorState.scriptGenState.importInfosForWireAdapter.add(importInfo);
+        }
+        if (!(0, static_analyzer_1.isSupportedNamespace)(importInfo.resourceName)) {
+            generatorState.scriptGenState.requiredFactoryFunctions.add(exports.ID.UNRESOLVED_VALUE);
+        }
+    }
+    return importInfo;
+}
+exports.updateImportInfoState = updateImportInfoState;
+/**
+ * Retrieve info about an import given its reference value (e.g. 0/names/0), without updating its state.
+ * To update ImportInfo state, see method updateImportInfoState.
+ * @param generatorState the current GeneratorState for this module generation
+ * @param importRefValue the import reference value to use in looking up the ImportInfo. ex: "0/names/0"
+ * @param isScriptFile boolean determining whether we are processing a script (JS) or template (HTML)
+ * @returns ImportInfo corresponding to the importRefValue in the generatorState
+ */
+function retrieveImportInfo(generatorState, importRefValue, isScriptFile) {
+    return isScriptFile
+        ? generatorState.scriptGenState.importRefsMap[importRefValue]
+        : generatorState.templateGenState.importRefsMap[importRefValue];
+}
+exports.retrieveImportInfo = retrieveImportInfo;
+// Return the variable declaration done via destructuring the factory object
+// (e.g. const { i, cg } = fct;) or undefined if no fct functions are used.
+function getFactoryFuncDeclaration(generatorState, isScriptFile) {
+    const fctFunctions = [];
+    const requiredFactoryFunctionsSet = isScriptFile
+        ? generatorState.scriptGenState.requiredFactoryFunctions
+        : generatorState.templateGenState.requiredFactoryFunctions;
+    // Only functions which are used within the module are actually assigned.
+    requiredFactoryFunctionsSet.forEach((funcId) => {
+        fctFunctions.push(t.objectProperty(funcId, funcId, false, true));
+    });
+    if (fctFunctions.length) {
+        const declarator = t.variableDeclarator(t.objectPattern(fctFunctions), exports.ID.FACTORY);
+        return t.variableDeclaration('const', [declarator]);
+    }
+}
+exports.getFactoryFuncDeclaration = getFactoryFuncDeclaration;
+// Convert a Komaci primitive value to babel expression.
+function primitiveToExpression(generatorState, primitive) {
+    switch (typeof primitive.value) {
+        case 'number':
+            return t.numericLiteral(primitive.value);
+        case 'string':
+            return t.stringLiteral(primitive.value);
+        case 'boolean':
+            return t.booleanLiteral(primitive.value);
+        case 'undefined':
+            return exports.ID.UNDEFINED;
+        default:
+            return t.nullLiteral();
+    }
+}
+exports.primitiveToExpression = primitiveToExpression;
+// Convert binding (or PropertyReference) to a babel expr (e.g. record.value?.Id).
+function bindingToExpression(generatorState, binding, isScriptFile) {
+    if (!binding.value.length) {
+        if (binding.type === 'Binding') {
+            throw new Error(exports.ERROR_PREFIX + 'encountered empty binding');
+        }
+        throw new Error(exports.ERROR_PREFIX + 'encountered empty property reference');
+    }
+    const segments = binding.value.split('/'); // segments[0] === propertyName
+    let chainingStartIdx;
+    let iteratorBinding = false;
+    // Am I in the context of an iteration?
+    if (generatorState.iterationContext.includes(segments[0])) {
+        // Referencing property of an iteration
+        iteratorBinding = true; // flag to distinguish whether we are in the context of an iteration
+        chainingStartIdx = 1;
+    }
+    else {
+        // Not referencing property of an iteration
+        // Are we referencing a property in the adg of the associated composition? Add to Set of reference properties on reaching this else
+        if (!isScriptFile) {
+            // put property into the Set of strings, and later convert into an array of stringLiterals later for arg 4
+            generatorState.templateGenState.refProps.add(segments[0]);
+        }
+        chainingStartIdx = 2;
+        segments.unshift(exports.CONTEXT, exports.PROPS); // Referencing property in context, so prepend ctx.props
+    }
+    // Build member expression w/ optional chaining to prevent runtime TypeError.
+    // If we are in the context of an iterator binding, we must prepend the user variable prefix
+    let expr = iteratorBinding
+        ? t.identifier(exports.USER_VARIABLE_PREFIX + segments[0])
+        : t.identifier(segments[0]);
+    for (let i = 1; i < segments.length; ++i) {
+        expr = t.optionalMemberExpression(expr, t.identifier(segments[i]), false, i > chainingStartIdx);
+    }
+    return expr;
+}
+exports.bindingToExpression = bindingToExpression;
+// Convert binding root (or PropertyReference) to a babel expr (e.g. ctx.prop.record).
+function bindingRootToExpression(generatorState, binding) {
+    if (!binding.value.length) {
+        if (binding.type === 'Binding') {
+            throw new Error(exports.ERROR_PREFIX + 'encountered empty binding');
+        }
+        throw new Error(exports.ERROR_PREFIX + 'encountered empty property reference');
+    }
+    const segments = binding.value.split('/').slice(0, 1);
+    let iterationBinding = false;
+    // not referencing property of an iteration.
+    if (!generatorState.iterationContext.includes(segments[0])) {
+        // Referencing property in context, so prepend ctx.props
+        segments.unshift(exports.CONTEXT, exports.PROPS);
+    }
+    else {
+        iterationBinding = true; // we are referencing a property of an iteration
+    }
+    // Build member expression w/ optional chaining to prevent runtime TypeError.
+    // if we are in the context of an iteration, prepend the user variable prefix
+    let expr = iterationBinding
+        ? t.identifier(exports.USER_VARIABLE_PREFIX + segments[0])
+        : t.identifier(segments[0]);
+    for (let i = 1; i < segments.length; ++i) {
+        expr = t.memberExpression(expr, t.identifier(segments[i]), false);
+    }
+    return expr;
+}
+exports.bindingRootToExpression = bindingRootToExpression;
+// Convert any possible value within a Komaci ADG to a babel expression.
+function valueToExpression(generatorState, komaciValue, isScriptFile, usageState) {
+    let newExpression;
+    switch (komaciValue.type) {
+        case 'PrimitiveValue':
+            newExpression = primitiveToExpression(generatorState, komaciValue);
+            break;
+        case 'ImportReference': {
+            const importInfo = updateImportInfoState(
+            // called from a lot of different places. Add a way to indicate where getImportInfo is being used.
+            generatorState, komaciValue.value, isScriptFile, usageState);
+            newExpression = importInfo.localName;
+            if (newExpression?.name !== exports.UNRESOLVED && komaciValue.namespacedMember) {
+                newExpression = t.memberExpression(newExpression, t.identifier(komaciValue.namespacedMember));
+            }
+            break;
+        }
+        case 'PropertyReference': {
+            return bindingToExpression(generatorState, komaciValue, isScriptFile);
+        }
+        case 'Binding': {
+            const objProps = [];
+            objProps.push(t.objectProperty(t.stringLiteral('url'), bindingToExpression(generatorState, komaciValue, isScriptFile)));
+            return t.objectExpression(objProps);
+        }
+        case 'Unresolved':
+            isScriptFile
+                ? generatorState.scriptGenState.requiredFactoryFunctions.add(exports.ID.UNRESOLVED_VALUE)
+                : generatorState.templateGenState.requiredFactoryFunctions.add(exports.ID.UNRESOLVED_VALUE);
+            newExpression = exports.ID.UNRESOLVED_VALUE;
+            break;
+        case 'ArrayValue': {
+            const elements = [];
+            komaciValue.value.forEach((element) => {
+                elements.push(valueToExpression(generatorState, element, isScriptFile, usageState));
+            });
+            newExpression = t.arrayExpression(elements);
+            break;
+        }
+        case 'ObjectValue': {
+            const objProps = [];
+            for (const [propName, propValue] of Object.entries(komaciValue.value)) {
+                objProps.push(t.objectProperty(t.stringLiteral(propName), valueToExpression(generatorState, propValue, isScriptFile, usageState)));
+            }
+            newExpression = t.objectExpression(objProps);
+            break;
+        }
+    }
+    if (!newExpression) {
+        throw new Error(`${exports.ERROR_PREFIX}: Unrecognized value type`);
+    }
+    return newExpression;
+}
+exports.valueToExpression = valueToExpression;
+/**
+ * Retrieve the file path for the js of a component
+ * @param generatorState GeneratorState containg the GeneratorInput, which in turn contains the JS raw source file
+ * @returns Returns raw source code as string for the js of a component if it exists in the srcFileMap
+ *          Returns undefined if no JS source file (whose filename also matches the LWC module name) was included in the
+ *          GeneratorState.GeneratorInput by lwc-platform, other calling code.
+ */
+function getComponentSrcJs(generatorState) {
+    let sourceCode;
+    const moduleName = generatorState.input.moduleInfo.name;
+    if (generatorState.input.srcFileMap) {
+        const filename = Object.keys(generatorState.input.srcFileMap).find((filename) => filename.endsWith('.js') && filename.startsWith(moduleName));
+        if (filename) {
+            sourceCode = generatorState.input.srcFileMap[filename];
+        }
+    }
+    return sourceCode;
+}
+exports.getComponentSrcJs = getComponentSrcJs;
+/**
+ * AST is traversed to see if they contain getter functions that are not valid. For each getter that is valid, we will
+ * update contextual information about the class and pass back info about the valid getters.
+ *
+ * @param {ClassPropertyContexts} properties the Map of properties metadata, which tells whether a property is used by a wire functions
+ * @param {ModuleContext} moduleContext Contextual info about the module itself
+ * @param {ModuleLevelConsumption} moduleLevelConsumption Details about how things are consuming module level entities. NOTE: This is updated in here for import usage
+ * @param {t.File} ast The ast for the module
+ * @returns Information about valid getters to be added to the resolvable Module.
+ */
+function processGetters(properties, moduleContext, moduleLevelConsumption, getterMethodPaths) {
+    return (getterMethodPaths
+        // filter removes invalid getters from the array
+        .filter((getter) => (0, static_analyzer_1.validateGetter)(getter, moduleContext, false))
+        // map changes the item at each index to be an instance of ValidGetterContext
+        .map((getter, index) => {
+        const { identifiers } = (0, common_shared_1.implicitConsumptionMetadata)(getter, moduleContext.astContext.classProperties, // info on all class properties
+        moduleContext.astContext.importDeclarations, // import metadata info
+        moduleLevelConsumption);
+        if (identifiers.length > 0) {
+            identifiers.forEach((identifier) => {
+                properties.get(identifier);
+            });
+        }
+        return {
+            getter,
+            generatedName: `g${index}`,
+            memberUsage: identifiers,
+        };
+    })
+        .map((getter) => {
+        (0, common_shared_1.updatePropertyUsage)((0, common_shared_1.getClassMethodName)(getter.getter), getter.memberUsage, properties, common_shared_1.PropertyTypes.GETTER);
+        return getter;
+    }));
+}
+exports.processGetters = processGetters;
+/**
+ * This method takes in the generatedCombinedModule AST, the original source AST, the import references map from the
+ * GeneratorState, and the valid getter contexts (which contain the babel NodePaths to the getters) and transforms the generated
+ * combined module AST by hoisting any passed-in valid getters into top-level getter methods, adding `props` as input paramater to the
+ * same getter methods, replacing this.<var> references in the getter method to props.<var>, as well as replacing references of
+ * valid imports references in the getter with corresponding Komaci module unique identifiers (i1, i2, i3,...).
+ *
+ * @param genCombinedModuleAST the AST of the generated combined module
+ * @param importReferencesMap Map of importReferences (ex: "0/names/0") to ImportInfo, which comes from GeneratorState's scriptGenState.importRefsMap
+ * @param getterImportUsage All the imports decalred in the ast
+ * @param validGetterContexts Array of ValidGetterContext object which contain the NodePath representing the getter, as well as an Array<string> of
+ *                            memberUsages within the same getter.
+ */
+function transformGetters(genCombinedModuleAST, importReferencesMap, getterImportUsage, validGetterContexts) {
+    const trueToGeneratedImport = mapRealNameToGenerated(importReferencesMap);
+    let body = [];
+    const hoistedGetters = [];
+    for (const getterCtx of validGetterContexts) {
+        sanitizeFunction(getterCtx.getter, getterImportUsage, trueToGeneratedImport);
+        // hoist getters to module-level
+        // use direct-access here since it is possible for this portion
+        const program = genCombinedModuleAST.program;
+        body = program.body;
+        const propsId = t.identifier(exports.PROPS);
+        const hoistedGetter = t.functionDeclaration(t.identifier(getterCtx.generatedName), [propsId], // make 'props' an input parameter to the hoisted getter
+        getterCtx.getter.node.body);
+        hoistedGetters.push(hoistedGetter);
+    }
+    // add hoisted getter functions in the array of Statements for the program body, in the first spot after
+    // all of the ImportDeclarations
+    const insertBeforeIndex = body.findIndex((statement) => statement.type !== 'ImportDeclaration');
+    body.splice(insertBeforeIndex, 0, ...hoistedGetters);
+}
+exports.transformGetters = transformGetters;
+/**
+ * Function to update the Komaci Document with validated getter information. This function will update the functions array in the
+ * export default adg along with the property references in the property array.
+ * @param komaciScriptDoc the komaci document
+ * @param validGetterContext a collection
+ */
+function updateKomaciDocumentWithValidGetters(komaciScriptDoc, validGetterContext) {
+    if (komaciScriptDoc.exports) {
+        //get the exort mapping for the export default
+        const defaultExportMapping = komaciScriptDoc.exports['default'];
+        if (defaultExportMapping && defaultExportMapping.type === 'AdgReference') {
+            const defaultExportAdg = komaciScriptDoc.adgs?.[defaultExportMapping.value];
+            //foreach getter in the context.
+            validGetterContext.forEach((getter) => {
+                //Get the name of the getter.
+                const getterName = getter.getter.node.key.name;
+                const inputArr = {
+                    type: 'ArrayValue',
+                    value: [],
+                };
+                getter.memberUsage.forEach((member) => {
+                    const primVal = {
+                        type: 'PrimitiveValue',
+                        value: member,
+                    };
+                    inputArr.value.push(primVal);
+                });
+                //create a new functionType obj with getter information.
+                const validGetterFunction = {
+                    type: exports.GETTER_FUNCTION,
+                    reference: { type: 'InternalReference', value: getter.generatedName },
+                    input: [inputArr],
+                    location: undefined,
+                };
+                //if we have an adg make changes to it.
+                if (defaultExportAdg) {
+                    getter.f_index = addPropertyFunction(defaultExportAdg, getterName, validGetterFunction);
+                }
+            });
+        }
+    }
+}
+exports.updateKomaciDocumentWithValidGetters = updateKomaciDocumentWithValidGetters;
+/**
+ * Validate what templates are good and then uplift the metadata about how they interact with other portions of the modules.
+ * i.e. import, property references, used in priming
+ * @param {ClassPropertyContexts} properties the Map of properties metadata, which tells whether a property is used by a wire functions
+ * @param {ModuleContext} moduleContext Contextual info about the module itself
+ * @param {ModuleLevelConsumption} moduleLevelConsumption Details about how things are consuming module level entities. NOTE: This is updated in here for import usage
+ * @param {Array<NodePath<t.ClassProperty>>} templateStrings The templates to validate
+ * @returns Information about valid templates to be added to the resolvable Module.
+ */
+function processTemplateStrings(properties, moduleContext, moduleLevelConsumption, templateStrings) {
+    return templateStrings
+        .filter((template) => (0, static_analyzer_1.validateTemplateString)(template, moduleContext, false))
+        .map((template, index) => {
+        const { identifiers } = (0, common_shared_1.implicitConsumptionMetadata)(template, moduleContext.astContext.classProperties, // info on all class properties
+        moduleContext.astContext.importDeclarations, // import metadata info
+        moduleLevelConsumption);
+        return {
+            template,
+            generatedName: `t${index}`,
+            memberUsage: identifiers,
+        };
+    })
+        .map((template) => {
+        (0, common_shared_1.updatePropertyUsage)((0, common_shared_1.getFromIdentifierOrStringLiteral)(template.template.node.key), template.memberUsage, properties, common_shared_1.PropertyTypes.TEMPLATE_STRING);
+        return template;
+    });
+}
+exports.processTemplateStrings = processTemplateStrings;
+/**
+ * Converts templates into single line functions, hoisted to the top level of the resolvable module.
+ * Part of this hoisting is going through and updating references to properties or imports. similar to what we do for getters.
+ *
+ * @param genCombinedModuleAST the AST of the generated combined module
+ * @param importReferencesMap Map of importReferences (ex: "0/names/0") to ImportInfo, which comes from GeneratorState's scriptGenState.importRefsMap
+ * @param definedImports All the imports decalred in the ast
+ * @param validGetterContexts Array of valid templates
+ */
+function hoistTemplateStrings(genCombinedModuleAST, importReferencesMap, definedImports, templateStrings) {
+    const trueToGeneratedImport = mapRealNameToGenerated(importReferencesMap);
+    let body = [];
+    const hoistedTemplateStrings = [];
+    for (const templateString of templateStrings) {
+        sanitizeFunction(templateString.template, definedImports, trueToGeneratedImport);
+        const program = genCombinedModuleAST.program;
+        body = program.body;
+        const propsId = t.identifier(exports.PROPS);
+        const hoistedGetter = t.functionDeclaration(t.identifier(templateString.generatedName), [propsId], t.blockStatement([t.returnStatement(templateString.template.node.value)]));
+        hoistedTemplateStrings.push(hoistedGetter);
+    }
+    const insertBeforeIndex = body.findIndex((statement) => statement.type !== 'ImportDeclaration');
+    body.splice(insertBeforeIndex, 0, ...hoistedTemplateStrings);
+}
+exports.hoistTemplateStrings = hoistTemplateStrings;
+/**
+ * Create a mapping from the original name of an import to the generated one made by komaci
+ * @param importReferencesMap The inverse mapping of generated name to info
+ * @returns A map of original import name to generated name
+ */
+function mapRealNameToGenerated(importReferencesMap) {
+    const trueToGeneratedImport = new Map();
+    for (const ref of Object.values(importReferencesMap)) {
+        if (ref.importSpecifier.type === 'ImportDefaultSpecifier' ||
+            ref.importSpecifier.type === 'ImportNamespaceSpecifier') {
+            trueToGeneratedImport.set(ref.resourceName, ref.localName.name);
+        }
+        else {
+            trueToGeneratedImport.set((0, common_shared_1.getFromIdentifierOrStringLiteral)(ref.importSpecifier.imported), ref.localName.name);
+        }
+    }
+    return trueToGeneratedImport;
+}
+exports.mapRealNameToGenerated = mapRealNameToGenerated;
+/**
+ * Take a function defined on a class and sanitize it's interactions in preparation to be hoisted into resolvable module/
+ *
+ * Two main things happen during sanitization:
+ * - references to imports are updated to their generated name (i.e. i2)
+ * - references to `this` are replaced with references to `props`
+ *
+ * @param nodePath The node to sanitize
+ * @param definedImports Metadata about all the imports we know about
+ * @param trueToGeneratedImport Mapping of real import name to generated name
+ */
+function sanitizeFunction(nodePath, definedImports, trueToGeneratedImport) {
+    const Visitors = {
+        Identifier(path) {
+            if ((path.parent.type === 'MemberExpression' &&
+                path.parent.property === path.node) ||
+                path.parent.type === 'Decorator') {
+                //when a property shares a same name with an import,
+                //it will be identified as an import
+                //this check skips the scenario
+                return;
+            }
+            const info = definedImports.get(path.node.name);
+            let localName;
+            if (info && (info.isDefault || info.isNamespaceSpecifier)) {
+                localName = trueToGeneratedImport.get(info.namespace);
+            }
+            else if (info && info.trueName) {
+                localName = trueToGeneratedImport.get(info.trueName);
+            }
+            else if (info) {
+                localName = trueToGeneratedImport.get(info.identifierName);
+            }
+            if (localName && localName !== exports.UNRESOLVED) {
+                path.replaceWith(t.identifier(localName)); // replace usage of import specifier in getter
+            }
+            else if (localName === exports.UNRESOLVED) {
+                // legit this should never happen but if we somehow missed an edge case somewhere this will prevent a malformed module from going out
+                throw new Error(`${exports.ERROR_PREFIX}: '${path.node.name}' does not map to valid import`);
+            }
+        },
+        MemberExpression(path) {
+            if (path.node.object.type === 'ThisExpression') {
+                path.replaceWith(t.memberExpression(t.identifier(exports.PROPS), path.node.property)); // replace this.<var> with props.<var>
+            }
+        },
+    };
+    nodePath.traverse(Visitors);
+}
+exports.sanitizeFunction = sanitizeFunction;
+/**
+ * Function to update the Komaci Document with validated template information. This function will update the functions array in the
+ * export default adg along with the property references in the property array.
+ * @param komaciScriptDoc the komaci document
+ * @param ValidTemplateContext details about the templates we've deemed to be valid
+ */
+function updateKomaciDocumentWithValidTemplatedStrings(komaciScriptDoc, templateStrings) {
+    if (komaciScriptDoc.exports?.default?.type === 'AdgReference') {
+        const adg = komaciScriptDoc.adgs?.[komaciScriptDoc.exports.default.value];
+        if (adg) {
+            templateStrings.forEach((template) => {
+                const propertyName = template.template.node.key.name;
+                const inputArr = {
+                    type: 'ArrayValue',
+                    value: [],
+                };
+                template.memberUsage.forEach((member) => {
+                    const primVal = {
+                        type: 'PrimitiveValue',
+                        value: member,
+                    };
+                    inputArr.value.push(primVal);
+                });
+                const validTemplateStringFunction = {
+                    type: exports.TEMPLATED_STRING_FUNCTION,
+                    reference: {
+                        type: 'InternalReference',
+                        value: template.generatedName,
+                    },
+                    input: [inputArr],
+                    location: undefined,
+                };
+                //if we have an adg make changes to it.
+                if (adg) {
+                    template.f_index = addPropertyFunction(adg, propertyName, validTemplateStringFunction);
+                }
+            });
+        }
+    }
+}
+exports.updateKomaciDocumentWithValidTemplatedStrings = updateKomaciDocumentWithValidTemplatedStrings;
+/**
+ * Update the functions array with the newly formed function reference and point the property to it
+ * @param adg The adg to update
+ * @param propertyName name of the property to update
+ */
+function addPropertyFunction(adg, propertyName, func) {
+    if (!adg.functions) {
+        adg.functions = [];
+    }
+    if (!adg.properties) {
+        adg.properties = {};
+    }
+    //push getter onto array get the length.
+    const fIndex = adg.functions.push(func);
+    const refIndex = fIndex - 1;
+    //create new property to reference function array.
+    const property = {
+        isPublic: adg.properties[propertyName]?.isPublic || false,
+        input: {
+            type: 'FunctionReference',
+            value: refIndex,
+        },
+    };
+    adg.properties[propertyName] = property;
+    return refIndex;
+}
+exports.addPropertyFunction = addPropertyFunction;
+//# sourceMappingURL=shared.js.map