@komaci/esm-generator 240.1.3 → 242.1.0

package/build/modGenTemplate.d.ts

@@ -1,37 +0,0 @@
-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

@@ -1,402 +0,0 @@
-"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

@@ -1,170 +0,0 @@
-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