@komaci/esm-generator 240.1.5 → 242.1.1

package/build/functionAstGeneration.js

@@ -0,0 +1,345 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.produceErrorAdgFunction = exports.getInlineFunctionFromTemplateCompositions = exports.getAdgFunctionBody = exports.addExportStatement = exports.composeAdgFunction = exports.getFactoryFuncDeclaration = exports.adgToExpression = exports.sanitizeFunction = exports.hoistLocalFunction = void 0;
+const t = __importStar(require("@babel/types"));
+const common_shared_1 = require("@komaci/common-shared");
+const compositionAstGeneration_1 = require("./compositionAstGeneration");
+const genericAstGeneration_1 = require("./genericAstGeneration");
+const types_1 = require("./types");
+/**
+ * Take a local function (getter, template string, etc) and prepare it for the resolvable module
+ * - sanitize the function
+ * - give the function a module level signature with generated name
+ *
+ * @param functionMetadata Metadata about the function to hoist
+ * @param importMetadata Map of all the import metadata we know about
+ *
+ * @returns a composed module level function or undefined if we don't have the
+ *          information for composing the funciton
+ */
+function hoistLocalFunction(functionMetadata, importMetadata) {
+    if (functionMetadata.componentAstNode && functionMetadata.generatedName) {
+        sanitizeFunction(functionMetadata.componentAstNode, importMetadata);
+        const propsId = t.identifier(common_shared_1.PROPS);
+        const functionBody = t.isClassMethod(functionMetadata.componentAstNode.node)
+            ? functionMetadata.componentAstNode.node.body
+            : t.blockStatement([
+                t.returnStatement(functionMetadata.componentAstNode.node.value),
+            ]);
+        const hoistedFunction = t.functionDeclaration(t.identifier(functionMetadata.generatedName), [propsId], // make 'props' an input parameter to the hoisted getter
+        functionBody);
+        return hoistedFunction;
+    }
+    return undefined;
+}
+exports.hoistLocalFunction = hoistLocalFunction;
+/**
+ * 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 importMetadata Metadata about all the imports we know about
+ */
+function sanitizeFunction(nodePath, importMetadata) {
+    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 = importMetadata.get(path.node.name);
+            if (info && info.isFromInternalNamespace && info.isFromSupportedLibrary) {
+                path.replaceWith(t.identifier(info.generatorAlias)); // replace usage of import specifier
+            }
+            else if (info &&
+                !(info.isFromInternalNamespace && info.isFromSupportedLibrary)) {
+                // 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(`${common_shared_1.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(common_shared_1.PROPS), path.node.property)); // replace this.<var> with props.<var>
+            }
+        },
+    };
+    nodePath.traverse(Visitors);
+}
+exports.sanitizeFunction = sanitizeFunction;
+/**
+ * Converts a Komaci ADG into a CallExpression to the ADG factory function
+ * call for the Resolver API.
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Adg} adg the current ADG to convert into an Expression
+ * @returns {t.Expression} Babel Expression representation of the adg() factory function call
+ */
+function adgToExpression(adg, moduleMetadata) {
+    const params = [];
+    // arg1: Parent Class.
+    if (adg.parentReference) {
+        let exp;
+        if (adg.parentReference.type === 'Unresolved') {
+            params.push(types_1.ID.UNRESOLVED_VALUE);
+        }
+        else if (adg.parentReference.type === 'ImportReference') {
+            const importId = moduleMetadata.importIndexReference.get(adg.parentReference.value);
+            if (importId) {
+                const importMetadata = moduleMetadata.importsByName.get(importId);
+                if (!importMetadata?.isFromInternalNamespace ||
+                    !importMetadata.isFromSupportedLibrary) {
+                    params.push(types_1.ID.UNRESOLVED_VALUE);
+                }
+                else {
+                    exp = t.identifier(importMetadata.generatorAlias);
+                    params.push(exp);
+                }
+            }
+        }
+        else {
+            if (adg.parentReference.type === 'AdgReference') {
+                const adgIndex = adg.parentReference.value;
+                const parentAdgRef = moduleMetadata.adgs.get(adgIndex);
+                if (parentAdgRef) {
+                    exp = t.identifier(parentAdgRef.defaultGeneratedName);
+                }
+                else {
+                    exp = types_1.ID.UNDEFINED;
+                }
+            }
+            else {
+                exp = (0, genericAstGeneration_1.valueToExpression)(adg.parentReference, moduleMetadata);
+            }
+            const parentFunc = t.callExpression(exp, [types_1.ID.FACTORY, types_1.ID.CONTEXT]);
+            params.push(parentFunc);
+        }
+    }
+    else {
+        params.push(types_1.ID.UNDEFINED);
+    }
+    // arg2: Properties object.
+    if (adg.properties) {
+        const objProps = [];
+        for (const [propName, propValue] of adg.properties) {
+            objProps.push(t.objectProperty(t.identifier(propName), (0, genericAstGeneration_1.propertyToExpression)(moduleMetadata, propValue)));
+        }
+        params.push(t.objectExpression(objProps));
+    }
+    else {
+        params.push(t.objectExpression([]));
+    }
+    // arg3: Functions array.
+    const functionsArray = [];
+    if (adg.functions) {
+        adg.functions.forEach((adgFunc) => {
+            const expr = (0, genericAstGeneration_1.functionToExpression)(moduleMetadata, adgFunc);
+            if (expr) {
+                functionsArray.push(expr);
+            }
+            else {
+                functionsArray.push(null);
+            }
+        });
+    }
+    if (functionsArray.length) {
+        params.push(t.arrayExpression(functionsArray));
+    }
+    else {
+        params.push(t.arrayExpression([]));
+    }
+    // arg4: Imported in-line composition function.
+    if (adg.compositions) {
+        params.push(getInlineFunctionFromTemplateCompositions(moduleMetadata, adg.requiredCompositionFactoryFunctions, adg.compositions));
+    }
+    else {
+        params.push(types_1.ID.DEFAULT_COMP);
+    }
+    // arg5: pass properties that the template references (only if processing a bundle)
+    // this array of t.stringLiterals may include properties mentioned the Template that aren't necessarily
+    // defined in the Script. Resolution engine has logic to handle these
+    params.push(t.arrayExpression(Array.from(adg.propertiesUsedInTemplate).map((v) => t.stringLiteral(v))));
+    return t.callExpression(types_1.ID.ADG_FUNC, params);
+}
+exports.adgToExpression = adgToExpression;
+/**
+ * Return the variable declaration done via destructuring the factory object
+ * (e.g. const { i, cg } = fct;) or undefined if no fct functions are used.
+ * @param factoryFuncs Set of strings that represent used factory functions
+ * @returns composed ast statement for factory functions
+ */
+function getFactoryFuncDeclaration(factoryFuncs) {
+    const fctFunctions = Array.from(factoryFuncs).map((func) => {
+        const funcId = types_1.ID[func];
+        return t.objectProperty(funcId, funcId, false, true);
+    });
+    if (fctFunctions.length) {
+        const declarator = t.variableDeclarator(t.objectPattern(fctFunctions), types_1.ID.FACTORY);
+        return t.variableDeclaration('const', [declarator]);
+    }
+}
+exports.getFactoryFuncDeclaration = getFactoryFuncDeclaration;
+/**
+ * composes ast statements for a given set of ADG Metadata
+ *
+ * @param adg the metadata for the adg we want to compose an ast for
+ * @param moduleMetadata Metadata about the entire module
+ * @returns the declaration for a given adg
+ */
+function composeAdgFunction(adg, moduleMetadata) {
+    // For each exported Adg create a corresponding export of a function
+    // which returns the AdgDefinition described in Resolver API.
+    const body = getAdgFunctionBody(adg, moduleMetadata);
+    return t.functionDeclaration(t.identifier(adg.defaultGeneratedName), [types_1.ID.FACTORY, types_1.ID.CONTEXT], body);
+}
+exports.composeAdgFunction = composeAdgFunction;
+/**
+ * associate composed adgs with their exported names
+ * @param adgName the name of the adg
+ * @param exportName the name it will be exported as
+ * @returns the composed export statement
+ */
+function addExportStatement(adgName, exportName) {
+    if (exportName === 'default') {
+        // e.g. `export default registerAdgFunction(adg0)`
+        return t.exportDefaultDeclaration(t.callExpression(t.identifier('registerAdgFunction'), [
+            t.identifier(adgName),
+        ]));
+    }
+    else {
+        // e.g  `export const Foo = registerAdgFunction(adg0)`
+        const expVar = t.variableDeclarator(t.identifier(exportName), t.callExpression(t.identifier('registerAdgFunction'), [
+            t.identifier(adgName),
+        ]));
+        return t.exportNamedDeclaration(t.variableDeclaration('const', [expVar]));
+    }
+}
+exports.addExportStatement = addExportStatement;
+/**
+ * Compose the function that calls the `adg` function with all of it's needful info
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {Adg} adg The current ADG for which to compose the babel statements
+ * @returns the babel statements to represent the function
+ */
+function getAdgFunctionBody(adg, moduleMetadata) {
+    const adgFuncCall = adgToExpression(adg, moduleMetadata);
+    const fctFuncs = getFactoryFuncDeclaration(adg.requiredAdgFactoryFunctions);
+    const funcStatements = [];
+    const body = t.blockStatement(funcStatements);
+    // Function body will be destructuring of factory object and the return
+    // statement for the adg() function call from Resolver API.
+    // e.g. `{ const { adg } = fct; return adg({...}); }`
+    if (fctFuncs) {
+        funcStatements.push(fctFuncs);
+    }
+    funcStatements.push(t.returnStatement(adgFuncCall));
+    return body;
+}
+exports.getAdgFunctionBody = getAdgFunctionBody;
+/**
+ * Converts array of template Compositions into a representation that is an inline function
+ * @param {GeneratorState} generatorState the current state of esm-generator
+ * @param {Composition[]} compositions array of Compositions to convert
+ * @returns {t.ArrowFunctionExpression} an inline ArrowFunctionExpression representing the input Compositions
+ */
+function getInlineFunctionFromTemplateCompositions(moduleMetadata, requiredFactoryFunctions, compositions) {
+    const params = [types_1.ID.FACTORY, types_1.ID.CONTEXT];
+    const statements = [];
+    const body = t.blockStatement(statements);
+    const emptyCompositionsArray = compositions.length < 1;
+    const compositionArrayExpr = emptyCompositionsArray
+        ? t.arrayExpression([])
+        : (0, compositionAstGeneration_1.compositionsToArrayExpression)(moduleMetadata, compositions) ||
+            t.arrayExpression([]);
+    // function body destructured factory object. e.g. `const { cg } = fct;`
+    const fctFuncs = getFactoryFuncDeclaration(requiredFactoryFunctions); // passing in false because we are not processing the script file in this method
+    if (fctFuncs && !emptyCompositionsArray) {
+        statements.push(fctFuncs);
+    }
+    statements.push(t.returnStatement(compositionArrayExpr));
+    return t.arrowFunctionExpression(params, body);
+}
+exports.getInlineFunctionFromTemplateCompositions = getInlineFunctionFromTemplateCompositions;
+/**
+ * A barebones resolvable module default export with a singular node describing the context of an error.
+ *
+ * We return this instead of a real resolvable module if something throws an error during resolvable module generation
+ * @param generatorState The state of the generator for pass through to adgToExpression
+ * @param error The error that was thrown
+ * @returns A default export representing the error state for this resolvable module
+ */
+function produceErrorAdgFunction(moduleMetadata, error) {
+    const functionValues = {
+        error: {
+            type: 'PrimitiveValue',
+            value: error instanceof Error
+                ? error.message
+                : common_shared_1.ERROR_PREFIX + 'Something that is not an error was thrown',
+        },
+    };
+    if (error instanceof Error && error.stack) {
+        functionValues.stack = {
+            type: 'PrimitiveValue',
+            value: error.stack,
+        };
+    }
+    const registerAdgImport = t.importDeclaration([t.importDefaultSpecifier(t.identifier('registerAdgFunction'))], t.stringLiteral('komaci/registerAdgFunction'));
+    const adg = (0, common_shared_1.initAdgMetadataObject)('adg0');
+    adg.compositions = [];
+    adg.requiredAdgFactoryFunctions.add(common_shared_1.IdKeys.ADG_FUNC);
+    adg.functions.push({
+        type: common_shared_1.FunctionTypes.ERROR,
+        input: [
+            {
+                type: 'ObjectValue',
+                value: functionValues,
+            },
+        ],
+    });
+    adg.requiredAdgFactoryFunctions.add(common_shared_1.IdKeys.ADG_FUNC);
+    const adgFuncCall = adgToExpression(adg, moduleMetadata);
+    const factoryFuncs = getFactoryFuncDeclaration(adg.requiredAdgFactoryFunctions);
+    const funcDec = t.functionDeclaration(t.identifier(adg.defaultGeneratedName), [types_1.ID.FACTORY, types_1.ID.CONTEXT], t.blockStatement([
+        // it is literally impossible for this to be undefined given the adgToExpression call
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        factoryFuncs,
+        t.returnStatement(adgFuncCall),
+    ]));
+    return t.program([
+        registerAdgImport,
+        funcDec,
+        t.exportDefaultDeclaration(t.callExpression(t.identifier('registerAdgFunction'), [
+            t.identifier(adg.defaultGeneratedName),
+        ])),
+    ]);
+}
+exports.produceErrorAdgFunction = produceErrorAdgFunction;
+//# sourceMappingURL=functionAstGeneration.js.map

package/build/genericAstGeneration.d.ts

@@ -0,0 +1,115 @@
+import { ClassPropertyContext, ErrorFunctionMetadata, FunctionMetadata, ModuleMetadata, WireFunctionMetadata } from '@komaci/common-shared';
+import * as t from '@babel/types';
+import { GeneratorInput } from './types';
+import { Binding, PrimitiveValue, PropertyReference, Value, KomaciDocument } from '@komaci/types';
+/**
+ * Compose a resolvable module for a component. There are three types of outputted resolvable modules
+ * - A resolvable module built from a component with ONLY a template
+ * - A resolvable module built from a component with ONLY a js file
+ * - A resolvable module that has both a template a js file
+ *
+ * Currently we only support JS and template files that match the names of components
+ *
+ * @param input Generator input
+ * @param scriptKomaciDoc The js komaci doc if it exists
+ * @param templateKomaciDocMap A map of template komaci docs.
+ * @param source string pointing to the source of the script doc if it exists
+ * @returns The babel AST for the generated resolvable module
+ */
+export declare function generateResolvableModule(input: GeneratorInput, scriptKomaciDoc?: KomaciDocument, templateKomaciDocMap?: {
+    [fName: string]: KomaciDocument;
+}, source?: string): t.File;
+/**
+ * Adds a babel import decleration to the AST for each Komaci import
+ *
+ * Note: While this method does not return anything, it does modify the input Statement array.
+ *
+ * @param {ModuleMetadata} moduleMetadata metadata about the lwc module we are building a resolvable module for
+ * @param {Statement[]} statements Array of Statement to be modified by this method for this program
+ * @param {{ calledFromGenerateCombinedModule: boolean }} options flag to distinguish whether we have been called
+ * to generate a combined module or not.
+ */
+export declare function addImportStatements(moduleMetadata: ModuleMetadata, statements: t.Statement[], options: {
+    calledFromGenerateCombinedModule: boolean;
+}): void;
+/**
+ * Make ast statements for the details about an error we received
+ * @param adgFunc The error function metadata
+ * @param moduleMetadata metadata about the module as whole
+ * @returns ast statemenets representing config for this function node
+ */
+export declare function processErrorFunction(adgFunc: ErrorFunctionMetadata, moduleMetadata: ModuleMetadata): t.ObjectProperty[];
+/**
+ * Function to generate the object property array for a wire function node type.
+ *
+ * NOTE: if the obj representing the function is from an unsupported namespace, and it
+ * is for a wire function, then leave out the function node from the generated resolvable
+ * module, by returning undefined.
+ * @param {ImportInfo} importInfo import information against which to check the wire function's validity
+ * @param {GeneratorState} generatorState the current state of the esm generator
+ * @param {FunctionType} adgFunc a wire function from the adg functions array.
+ * @returns {ObjectProperty[]} an representation of the wire function node as array of ObjectProperty
+ */
+export declare function processWireFunctionType(adgFunc: WireFunctionMetadata, moduleMetadata: ModuleMetadata): t.ObjectProperty[] | undefined;
+/**
+ * Convert any possible value within a Komaci ADG to a babel expression.
+ * @param komaciValue the komaci value
+ * @param moduleMetadata the module meta data object
+ * @returns a babel expression for the komaci value.
+ */
+export declare function valueToExpression(komaciValue: Value, moduleMetadata: ModuleMetadata): t.Expression;
+/**
+ * Convert a Komaci primitive value to babel expression.
+ * @param primitive a primitve value
+ * @returns an expression that represents the primitive value.
+ */
+export declare function primitiveToExpression(primitive: PrimitiveValue): t.Expression;
+/**
+ * Convert binding (or PropertyReference) to a babel expr (e.g. record.value?.Id).
+ * @param binding The binding object
+ * @param iterationContext If this binding is inside an iteration we need the contextual details about the iteration to build the proper expression
+ * @param parseRootOnly There are some cases where we only care about the first piece of the binding. in the example above we might need to only check `record` instead of `record.value?.Id`
+ * @returns A composed member expression
+ */
+export declare function bindingToExpression(binding: Binding | PropertyReference, iterationContext?: string[], parseRootOnly?: boolean): t.Identifier | t.OptionalMemberExpression;
+/**
+ * Convert a single Komaci function to an object expression in the shape of a
+ * FunctionDefinition as defined in Resolver API.
+ * @param {GeneratorState} generatorState the current esm generator state
+ * @param {FunctionType} adgFunc a function from the adg functions arrray.
+ * @returns {Expression} a babel Expression if propertly processed or undefined.
+ */
+export declare function functionToExpression(moduleMetadata: ModuleMetadata, adgFunc: FunctionMetadata): t.ObjectExpression | undefined;
+/**
+ * Convert a single Komaci property to an object expression in the shape of
+ * a PropertyDefinition as defined in Resolver API.
+ * @param {GeneratorState} generatorState the current state of esm-generator
+ * @param {Adg} adg the current ADG from which to seek out FunctionReferences
+ * @param {Propery} property the Komaci property to process
+ * @returns {Expression} the komaci property converted to an object Expression
+ */
+export declare function propertyToExpression(moduleMetadata: ModuleMetadata, property: ClassPropertyContext): t.ObjectExpression;
+/**
+ * Adds a default export to the program statements, if no default export that is derived from an AdgReference already exists
+ *
+ * @returns composed AST statement for undefined default export
+ */
+export declare function addUndefinedDefaultExport(): t.ExportDefaultDeclaration;
+/**
+ * Adds the dynamic import of target module, but only for bundles (if moduleInfo.type === "bundle").
+ *
+ * Returns an export named declaration. The declaration is assigned an arrowFunctionExpression, which returns
+ * a dynamic import based on the moduleInfo namespace and name.
+ * @param moduleName The name of module we're making
+ * @param moduleNamespace the namespace for this given module
+ * @param targetModule name of the target module if it exists
+ * @returns ExportNamedDeclaration containing the statement of the dynamic import of the target module
+ */
+export declare function exportNamedDeclarationForDynamicImport(moduleName: string, moduleNamespace: string, targetModule?: string): t.ExportNamedDeclaration;
+/**
+ * Helper function to collect metadata for non default templates.
+ * @param templateMap the map of html filenames to its generated komaci document
+ * @param defaultTemplateFileName the name of the default template.
+ */
+export declare function collectMetadataForNonDefaultTemplates(moduleMetadata: ModuleMetadata, defaultTemplateFileName: string): void;
+//# sourceMappingURL=genericAstGeneration.d.ts.map