@komaci/esm-generator 240.1.3

package/build/modGenTemplate.d.ts

@@ -0,0 +1,37 @@
+import * as t from '@babel/types';
+import { GeneratorState } from './types';
+import { KomaciDocument, Composition, Image } from '@komaci/types';
+/**
+ * Generates the resolvable module for a single template file
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {KomaciDocument} komaciDoc the KomaciDocument representation of the Template (HTML) file
+ * @returns {File} the babel/types File representation of the Template (i.e. the AST of the Template file)
+ */
+export declare function generateTemplateModule(generatorState: GeneratorState, komaciDoc: KomaciDocument): t.File;
+/**
+ * Processes the imports for the template Komaci document
+ * @param {KomaciDocument} komaciDoc KomaciDocument for the template file
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Statement[]} statements the array of Statement to which to add the import declaration. Should
+ * likely be empty as input.
+ */
+export declare function processTemplateImports(komaciDoc: KomaciDocument, generatorState: GeneratorState, statements: t.Statement[]): void;
+/**
+ * Convert an array of Komaci Compositions into a babel array of expressions.
+ * This is used for both the top-level compositions in the Komaci Doc, as well
+ * as their nested child compositions.
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {boolean} isScriptFile whether this method is called in the context of processing a Script (JS) file
+ * @param {Composition[]} compositions an array of Compositions from a Template JS
+ * @returns {ArrayExpression | undefined} an ArrayExpression representing the passed in Composition array, or undefined
+ * if no compositions were passed in
+ */
+export declare function compositionsToArrayExpression(generatorState: GeneratorState, isScriptFile: boolean, compositions?: Composition[]): t.ArrayExpression | undefined;
+/**
+ * Converts Komaci Image into prompt for the Resolver API to make an image priming call
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Image} image the Image node from the KomaciDocument
+ * @returns {Expression} the babel Expression representing the Image prompt into the Resolver API
+ */
+export declare function imageToExpression(generatorState: GeneratorState, image: Image): t.Expression;
+//# sourceMappingURL=modGenTemplate.d.ts.map

package/build/modGenTemplate.js

@@ -0,0 +1,402 @@
+"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.imageToExpression = exports.compositionsToArrayExpression = exports.processTemplateImports = exports.generateTemplateModule = void 0;
+/* eslint-disable @typescript-eslint/no-use-before-define */
+const t = __importStar(require("@babel/types"));
+const shared_1 = require("./shared");
+const types_1 = require("./types");
+const common_shared_1 = require("@komaci/common-shared");
+/**
+ * Generates the resolvable module for a single template file
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {KomaciDocument} komaciDoc the KomaciDocument representation of the Template (HTML) file
+ * @returns {File} the babel/types File representation of the Template (i.e. the AST of the Template file)
+ */
+function generateTemplateModule(generatorState, komaciDoc) {
+    const statements = [];
+    const program = t.program(statements);
+    const file = t.file(program);
+    // Process the template's imports
+    processTemplateImports(komaciDoc, generatorState, statements);
+    // Traverse compositions tree to construct array of expressions.
+    // One for each Komaci Composition including it's nested children.
+    const compositionsArray = compositionsToArrayExpression(generatorState, false, komaciDoc.compositions) ||
+        t.arrayExpression([]);
+    // Create default export of the main template function.
+    // e.g. `export default function (fct, ctx) {...}`
+    statements.push(t.exportDefaultDeclaration(getMainFunction(generatorState, compositionsArray)));
+    return file;
+}
+exports.generateTemplateModule = generateTemplateModule;
+/**
+ * Processes the imports for the template Komaci document
+ * @param {KomaciDocument} komaciDoc KomaciDocument for the template file
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Statement[]} statements the array of Statement to which to add the import declaration. Should
+ * likely be empty as input.
+ */
+function processTemplateImports(komaciDoc, generatorState, statements) {
+    if (komaciDoc.imports) {
+        for (let i = 0; i < komaciDoc.imports.length; ++i) {
+            const komaciImport = komaciDoc.imports[i];
+            const localName = t.identifier(`${shared_1.ADG_IMPORT_SUFFIX}${++generatorState.adgImportSuffix}`);
+            let resourceName = komaciImport.resourceName;
+            // If template is inline the imports will be for combined module,
+            // so remove the file portion of the import. For example:
+            // @salesforce/komaci/c__child1__child1.js -> @salesforce/komaci/c__child1
+            if (generatorState.inlineTemplateDoc) {
+                const lastIndex = resourceName.lastIndexOf('__');
+                resourceName = resourceName.slice(0, lastIndex);
+            }
+            // e.g. `import adg1 from "@salesforce/komaci/c__child1__child1.js";`
+            const specifier = t.importDefaultSpecifier(localName);
+            const source = t.stringLiteral(resourceName);
+            const importDeclaration = t.importDeclaration([specifier], source);
+            statements.push(importDeclaration);
+            const importInfo = {
+                localName,
+                componentId: importToComponentId(komaciImport),
+                resourceName,
+                // below fields not used for template ImportInfos
+                exportName: undefined,
+                importUsages: new Set(),
+                importSpecifier: specifier,
+                importDeclaration: importDeclaration,
+            };
+            generatorState.templateGenState.importRefsMap[`${i}/names/0`] = importInfo;
+        }
+    }
+}
+exports.processTemplateImports = processTemplateImports;
+/**
+ * Convert an array of Komaci Compositions into a babel array of expressions.
+ * This is used for both the top-level compositions in the Komaci Doc, as well
+ * as their nested child compositions.
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {boolean} isScriptFile whether this method is called in the context of processing a Script (JS) file
+ * @param {Composition[]} compositions an array of Compositions from a Template JS
+ * @returns {ArrayExpression | undefined} an ArrayExpression representing the passed in Composition array, or undefined
+ * if no compositions were passed in
+ */
+function compositionsToArrayExpression(generatorState, isScriptFile, compositions) {
+    if (!compositions) {
+        return undefined;
+    }
+    const elements = [];
+    compositions.forEach((composition) => {
+        const expr = compositionToExpression(generatorState, composition, isScriptFile);
+        if (expr) {
+            if (t.isArrayExpression(expr)) {
+                // Special case, such as the top-most container, where the container has
+                // no impact on resolution process. In which case we want to flatten
+                // the array to effectively remove the container from the generated mod.
+                expr.elements.forEach((element) => {
+                    if (t.isExpression(element)) {
+                        elements.push(element);
+                    }
+                });
+            }
+            else {
+                elements.push(expr);
+            }
+        }
+    });
+    return t.arrayExpression(elements);
+}
+exports.compositionsToArrayExpression = compositionsToArrayExpression;
+/**
+ * Convert any of the Komaci composition types into a babel expression, to be included in the generated module.
+ * NOTE: For instances where a composition has an isActive coditional, the module will be using the u function provided by the fct factory object to
+ * to check for an unresolved value. This function can be overridden, otherwise the default implementaitno will be used. https://salesforce.quip.com/XY4WAbfaLR5E
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Composition} composition the Composition to covert
+ * @param {boolean} isScriptFile boolean indicating whether this method is being called in the context of processing a JS Script file
+ * @returns {Expression | ArrayExpression} the babel expression (Expression | ArrayExpression) to which the Composition was converted
+ */
+function compositionToExpression(generatorState, composition, isScriptFile) {
+    let expression;
+    // Get the expression specific to each type of composition.
+    switch (composition.type) {
+        case 'Container':
+            expression = containerToExpression(generatorState, composition, isScriptFile);
+            break;
+        case 'ComposedAdg':
+            expression = composedAdgToExpression(generatorState, composition, isScriptFile);
+            break;
+        case 'Iteration':
+            expression = iterationToExpression(generatorState, composition, isScriptFile);
+            break;
+        case 'Slot':
+            expression = slotToExpression(generatorState, composition);
+            break;
+        case 'Image':
+            expression = imageToExpression(generatorState, composition);
+            break;
+    }
+    // If the composition has an isActive condition, then
+    // expression needs to be proceded by a conditional check.
+    if (composition.isActive) {
+        // when checking conditional, always check unresolved
+        generatorState.templateGenState.requiredFactoryFunctions.add(shared_1.ID.UNRESOLVED_FUNC);
+        let conditionalTest = (0, shared_1.bindingToExpression)(generatorState, composition.isActive.input, isScriptFile);
+        if (composition.isActive.negate) {
+            conditionalTest = t.unaryExpression('!', conditionalTest);
+        }
+        const prop = (0, shared_1.bindingRootToExpression)(generatorState, composition.isActive.input);
+        const unresolvedTest = t.callExpression(shared_1.ID.UNRESOLVED_FUNC, [prop]);
+        const test = t.logicalExpression('||', unresolvedTest, conditionalTest);
+        expression = t.conditionalExpression(test, expression, shared_1.ID.UNDEFINED);
+    }
+    if ((0, common_shared_1.isCompositionAnImage)(composition) && expression) {
+        generatorState.templateGenState.requiredFactoryFunctions.add(shared_1.ID.IMG_FUNC);
+    }
+    return expression;
+}
+/**
+ * Converts a Komaci container into a babel expression. If the container doesn't
+ * impact data flow, then an ArrayExpression is returned for its children.
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Container} container the Komaci container (i.e. <div> tag)
+ * @param {boolean} isScriptFile boolean indicating whether this method is being called in the context of processing a JS Script file
+ * @returns {Expression | ArrayExpression} The babel Expression or ArrayExpression converted from the input Container
+ */
+function containerToExpression(generatorState, container, isScriptFile) {
+    const children = compositionsToArrayExpression(generatorState, false, container.compositions) ||
+        t.arrayExpression([]);
+    // If key or slot is specified, then the container will need to be
+    // accounted for in the module via the element function.
+    if (container.key || container.slot) {
+        const params = [];
+        generatorState.templateGenState.requiredFactoryFunctions.add(shared_1.ID.ELEMENT_FUNC);
+        // arg1: Composition configuration.
+        params.push(getCompositionConfig(generatorState, container, isScriptFile));
+        // arg2: Context.
+        params.push(shared_1.ID.CONTEXT);
+        // arg3: Array of expressions for each child.
+        params.push(children);
+        return t.callExpression(shared_1.ID.ELEMENT_FUNC, params);
+    }
+    else {
+        // No key or slot, so only need to include it's children
+        // in the generated mod.
+        return children.elements.length === 1
+            ? children.elements[0]
+            : children;
+    }
+}
+/**
+ * Converts a Komaci ComposedAdg (which references an Import) into a call to the Resolver API for a composed graph, `cg`.
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {ComposedAdg} composedAdg the ComposedAdg whose input.type is an `ImportReference`
+ * @param {boolean} isScriptFile boolean indicating whether this method is being called in the context of processing a JS Script file
+ * @returns {Expression} a babel Expression representing the composed graph (cg) resolver API call. Throws an Error if the
+ * composedAdg.input.type is not equal to 'ImportReference'
+ */
+function composedAdgToExpression(generatorState, composedAdg, isScriptFile) {
+    let componentId;
+    const params = [];
+    generatorState.templateGenState.requiredFactoryFunctions.add(shared_1.ID.COMPOSED_GRAPH_FUNC);
+    // arg1: Input source to the composed graph function.
+    if (composedAdg.input.type === 'ImportReference') {
+        const importInfo = (0, shared_1.updateImportInfoState)(generatorState, composedAdg.input.value, false, types_1.ImportUsageState.composedadg);
+        componentId = importInfo.componentId;
+        params.push(importInfo.localName);
+    }
+    else {
+        // Schema supports this, but downstream logic (e.g. analysis) doesn't (yet).
+        throw new Error(shared_1.ERROR_PREFIX + 'binding not yet supported for ComposedAdg input');
+    }
+    // arg2: Composition configuration.
+    params.push(getCompositionConfig(generatorState, composedAdg, isScriptFile, componentId));
+    // arg3: Context.
+    params.push(shared_1.ID.CONTEXT);
+    // arg4: Array of expressions for each child.
+    const children = compositionsToArrayExpression(generatorState, isScriptFile, composedAdg.compositions);
+    if (children && children.elements.length) {
+        params.push(children);
+    }
+    return t.callExpression(shared_1.ID.COMPOSED_GRAPH_FUNC, params);
+}
+/**
+ * Converts a Komaci Iteration into a call to Resolver API for an iteration, i.e `i`.
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Iteration} iteration the Iteration from a template file
+ * @param {boolean} isScriptFile boolean indicating whether this method is being called in the context of processing a JS Script file
+ * @returns {Expression} the babel Expression that represents the call into the Resolver API for an iteration
+ */
+function iterationToExpression(generatorState, iteration, isScriptFile) {
+    const params = [];
+    generatorState.templateGenState.requiredFactoryFunctions.add(shared_1.ID.ITERATION_FUNC);
+    // arg1: Expression for the collection being iterated.
+    params.push((0, shared_1.bindingToExpression)(generatorState, iteration.input, isScriptFile));
+    // arg2: Context.
+    params.push(shared_1.ID.CONTEXT);
+    // arg3: Function to return compositions inside the the iteration.
+    // Use context to understand which iterations contain the code being analyzed.
+    generatorState.iterationContext.unshift(iteration.iterator);
+    const children = compositionsToArrayExpression(generatorState, isScriptFile, iteration.compositions) || t.arrayExpression([]);
+    generatorState.iterationContext.shift();
+    // interation.iterator contains string variables like "i", "j", "k", or loop control
+    // variables must prepend user variable prefix "user_var_" to the variable when used
+    // in arrow function declaration, to prevent resolution issues
+    params.push(t.arrowFunctionExpression([t.identifier(shared_1.USER_VARIABLE_PREFIX + iteration.iterator)], t.blockStatement([t.returnStatement(children)])));
+    return t.callExpression(shared_1.ID.ITERATION_FUNC, params);
+}
+/**
+ * Convert Komaci slot into call to Resolver API for a slot, `s`
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Slot} slot The Slot to be converted into an expression
+ * @returns {Expression} the babel Expression representing the Slot call into the Resolver API
+ */
+function slotToExpression(generatorState, slot) {
+    const params = [];
+    generatorState.templateGenState.requiredFactoryFunctions.add(shared_1.ID.SLOT_FUNC);
+    // arg1: Slot Name.
+    params.push(t.stringLiteral(slot.name));
+    // arg2: Composition configuration.
+    params.push(getCompositionConfig(generatorState, slot, false));
+    // arg3: Context.
+    params.push(shared_1.ID.CONTEXT);
+    // arg4: Array of expressions for each child.
+    const defaultContent = compositionsToArrayExpression(generatorState, false, slot.compositions);
+    if (defaultContent && defaultContent.elements.length) {
+        params.push(defaultContent);
+    }
+    return t.callExpression(shared_1.ID.SLOT_FUNC, params);
+}
+/**
+ * Converts Komaci Image into prompt for the Resolver API to make an image priming call
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Image} image the Image node from the KomaciDocument
+ * @returns {Expression} the babel Expression representing the Image prompt into the Resolver API
+ */
+function imageToExpression(generatorState, image) {
+    const params = [];
+    const funcObjProps = [];
+    if ((0, common_shared_1.isCompositionAnImage)(image)) {
+        if ((0, common_shared_1.isSrcPrimitiveValue)(image.src)) {
+            // type guard ensures `image.src` is a PrimitiveValue
+            // lwc-platform will NOT produce an Image KomaciNode with a blank or missing src attribute.
+            // However, just in case we do encounter this, we handle it here by simply NOT producing the
+            // function ObjectProperty for such a node.
+            if (image.src.value &&
+                typeof image.src.value === 'string' &&
+                image.src.value !== '') {
+                funcObjProps.push(t.objectProperty(shared_1.ID.IMG_SRC, t.stringLiteral(image.src.value)));
+            }
+        }
+        else if ((0, common_shared_1.isSrcABinding)(image.src)) {
+            // type guard ensures `image.src` is a Binding
+            // lwc-platform will NOT produce an Image KomaciNode with a blank or missing src attribute.
+            // However, just in case we do encounter this, we handle it here by simply NOT producing the
+            // function ObjectProperty for such a node.
+            if (image.src.value !== '') {
+                funcObjProps.push(t.objectProperty(shared_1.ID.IMG_SRC, (0, shared_1.bindingToExpression)(generatorState, image.src, true)));
+            }
+        }
+    }
+    params.push(t.objectExpression(funcObjProps));
+    return t.callExpression(shared_1.ID.IMG_FUNC, params);
+}
+exports.imageToExpression = imageToExpression;
+/**
+ * Creates a babel configuration ObjectExpression for provided composition. This is the `CompositionConfig`
+ * from Resolver API in its babel ObjectExpression form.
+ * @param {GeneratorState} generatorState the curent state of the esm generator
+ * @param {ComposedAdg | Container | Slot} composition the Composition from which to create a configuration (as a ComposedAdg, Container, or Slot)
+ * @param {boolean} isScriptFile boolean indicating whether this method is being called in the context of processing a JS Script file
+ * @param {string} componentId the component indentifier, as a string
+ * @returns {ObjectExpression} the babel ObjectExpression representing the Resolver API CompositionConfig
+ */
+function getCompositionConfig(generatorState, composition, isScriptFile, componentId) {
+    const config = [];
+    if (composition.slot) {
+        config.push(t.objectProperty(shared_1.ID.SLOT, t.stringLiteral(composition.slot)));
+    }
+    // ComposedAdg config contains additional information.
+    if (composition.type === 'ComposedAdg') {
+        if (componentId) {
+            config.push(t.objectProperty(shared_1.ID.COMPONENT_ID, t.stringLiteral(componentId)));
+        }
+        if (composition.properties) {
+            const props = [];
+            for (const propName of Object.keys(composition.properties)) {
+                const prop = composition.properties[propName];
+                if (prop.type === 'Binding') {
+                    props.push(t.objectProperty(t.identifier(propName), (0, shared_1.bindingToExpression)(generatorState, prop, isScriptFile)));
+                }
+                else if (prop.type === 'PrimitiveValue') {
+                    props.push(t.objectProperty(t.identifier(propName), (0, shared_1.primitiveToExpression)(generatorState, prop)));
+                }
+            }
+            config.push(t.objectProperty(shared_1.ID.PROPS, t.objectExpression(props)));
+        }
+    }
+    return t.objectExpression(config);
+}
+/**
+ * Convers an import in a Komaci template doc to a component identifier.
+ * Example:
+ * From: @salesforce/komaci/c__child1__child1.js
+ * To: c-child1
+ * @param {Import} komaciImport Komaci representation of an Import
+ * @returns {string} a string representing the component id generated from the import resource name
+ */
+function importToComponentId(komaciImport) {
+    // First split by '/' and confirm expected # segments.
+    let segments = komaciImport.resourceName.split('/');
+    if (segments.length !== 3) {
+        throw new Error(shared_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(shared_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}`;
+}
+/**
+ * Retrieves the babel FunctionDeclaration representation of the main function exported from the module being generated.
+ * e.g. `function (fct, ctx) { return ... }`
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param compositionExpressionsArray babel ArrayExpression representing the compositions expresions array
+ * @returns babel FunctionDeclaration representation of the main function exported from the module
+ */
+function getMainFunction(generatorState, compositionExpressionsArray) {
+    const params = [shared_1.ID.FACTORY, shared_1.ID.CONTEXT];
+    const statements = [];
+    const body = t.blockStatement(statements);
+    // Destructuring of factory functions.
+    const fctFuncs = (0, shared_1.getFactoryFuncDeclaration)(generatorState, false);
+    if (fctFuncs) {
+        statements.push(fctFuncs);
+    }
+    // Return the array of composition expressions.
+    statements.push(t.returnStatement(compositionExpressionsArray));
+    return t.functionDeclaration(null, params, body);
+}
+//# sourceMappingURL=modGenTemplate.js.map

package/build/shared.d.ts

@@ -0,0 +1,170 @@
+import * as t from '@babel/types';
+import { GeneratorState, ImportInfo, ImportUsageState } from './types';
+import { Binding, PrimitiveValue, Value, PropertyReference, FunctionType, KomaciDocument, Adg } from '@komaci/types';
+import { NodePath } from '@babel/core';
+import { ValidGetterContext, ValidTemplateContext, ModuleLevelConsumption, AstContext, ClassPropertyContexts, ModuleContext } from '@komaci/common-shared';
+export declare const ERROR_PREFIX = "[komaci esm-generator] ";
+export declare const CONTEXT = "ctx";
+export declare const PROPS = "props";
+export declare const ADG_IMPORT_SUFFIX = "getAdgDefinition";
+export declare const UNRESOLVED = "unresolved";
+export declare const USER_VARIABLE_PREFIX = "user_var_";
+export declare const WIRE_FUNCTION = "WireFunction";
+export declare const GETTER_FUNCTION = "GetterFunction";
+export declare const TEMPLATED_STRING_FUNCTION = "TemplatedStringFunction";
+export declare const ERROR_FUNCTION = "ErrorFunction";
+export declare const PRIMING_FUNCTION = "PrimingFunction";
+export declare const ID: {
+    CONTEXT: t.Identifier;
+    PROPS: t.Identifier;
+    FACTORY: t.Identifier;
+    COMPOSED_GRAPH_FUNC: t.Identifier;
+    ITERATION_FUNC: t.Identifier;
+    UNRESOLVED_FUNC: t.Identifier;
+    SLOT_FUNC: t.Identifier;
+    ELEMENT_FUNC: t.Identifier;
+    ADG_FUNC: t.Identifier;
+    SLOT: t.Identifier;
+    COMPONENT_ID: t.Identifier;
+    UNDEFINED: t.Identifier;
+    PROP_API: t.Identifier;
+    PROP_INIT: t.Identifier;
+    PROP_FUNC: t.Identifier;
+    PROP_GETTER: t.Identifier;
+    DEFAULT_COMP: t.Identifier;
+    FUNC_ID: t.Identifier;
+    FUNC_NAME: t.Identifier;
+    FUNC_TYPE: t.Identifier;
+    FUNC_CONFIG: t.Identifier;
+    FUNC_INPUT: t.Identifier;
+    WIRE_TYPE: t.Identifier;
+    UNRESOLVED_VALUE: t.Identifier;
+    BATCH_FUNC_ID: t.Identifier;
+    BATCH_FUNC_NAME: t.Identifier;
+    REDUCER_FUNC_ID: t.Identifier;
+    IMG_SRC: t.Identifier;
+    IMG_FUNC: t.Identifier;
+};
+/**
+ * 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
+ */
+export declare function updateImportInfoState(generatorState: GeneratorState, importRefValue: string, isScriptFile: boolean, usageState: ImportUsageState): ImportInfo;
+/**
+ * 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
+ */
+export declare function retrieveImportInfo(generatorState: GeneratorState, importRefValue: string, isScriptFile: boolean): ImportInfo;
+export declare function getFactoryFuncDeclaration(generatorState: GeneratorState, isScriptFile: boolean): t.VariableDeclaration | undefined;
+export declare function primitiveToExpression(generatorState: GeneratorState, primitive: PrimitiveValue): t.Expression;
+export declare function bindingToExpression(generatorState: GeneratorState, binding: Binding | PropertyReference, isScriptFile: boolean): t.Expression;
+export declare function bindingRootToExpression(generatorState: GeneratorState, binding: Binding | PropertyReference): t.Expression;
+export declare function valueToExpression(generatorState: GeneratorState, komaciValue: Value, isScriptFile: boolean, usageState: ImportUsageState): t.Expression;
+/**
+ * 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.
+ */
+export declare function getComponentSrcJs(generatorState: GeneratorState): string | undefined;
+/**
+ * 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.
+ */
+export declare function processGetters(properties: ClassPropertyContexts, moduleContext: ModuleContext, moduleLevelConsumption: ModuleLevelConsumption, getterMethodPaths: NodePath<t.ClassMethod>[]): ValidGetterContext[];
+/**
+ * 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.
+ */
+export declare function transformGetters(genCombinedModuleAST: t.File, importReferencesMap: {
+    [refId: string]: ImportInfo;
+}, getterImportUsage: AstContext['importDeclarations'], validGetterContexts: ValidGetterContext[]): void;
+/**
+ * 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
+ */
+export declare function updateKomaciDocumentWithValidGetters(komaciScriptDoc: KomaciDocument, validGetterContext: ValidGetterContext[]): void;
+/**
+ * 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.
+ */
+export declare function processTemplateStrings(properties: ClassPropertyContexts, moduleContext: ModuleContext, moduleLevelConsumption: ModuleLevelConsumption, templateStrings: Array<NodePath<t.ClassProperty>>): ValidTemplateContext[];
+/**
+ * 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
+ */
+export declare function hoistTemplateStrings(genCombinedModuleAST: t.File, importReferencesMap: {
+    [refId: string]: ImportInfo;
+}, definedImports: AstContext['importDeclarations'], templateStrings: ValidTemplateContext[]): void;
+/**
+ * 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
+ */
+export declare function mapRealNameToGenerated(importReferencesMap: {
+    [refId: string]: ImportInfo;
+}): Map<string, string>;
+/**
+ * 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
+ */
+export declare function sanitizeFunction(nodePath: NodePath<t.ClassProperty | t.ClassMethod>, definedImports: AstContext['importDeclarations'], trueToGeneratedImport: Map<string, string>): void;
+/**
+ * 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
+ */
+export declare function updateKomaciDocumentWithValidTemplatedStrings(komaciScriptDoc: KomaciDocument, templateStrings: ValidTemplateContext[]): void;
+/**
+ * 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
+ */
+export declare function addPropertyFunction(adg: Adg, propertyName: string, func: FunctionType): number;
+//# sourceMappingURL=shared.d.ts.map