@komaci/common-shared 240.1.5 → 242.1.1

package/build/utils.js

@@ -1,31 +1,13 @@
 "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.isDeclaredInAst = exports.isExpressionThisOrAlias = exports.getThisAliasDeclaredInGetter = exports.isPropertyNodeUsed = exports.isGetterNodeUsed = exports.isPropertyUsed = exports.getClassMethodName = exports.getVariablesDeclaredInGetter = exports.isExternalModule = exports.getAstContextObject = exports.getAllClassMethods = exports.getAllModuleVaraibles = exports.getAllModuleFunctions = exports.getAllImportReferences = exports.getFromIdentifierOrStringLiteral = exports.collectImportUsage = exports.getMemberVarsFromGetter = exports.implicitConsumptionMetadata = exports.getClassPropertyInfos = exports.getClassProperties = exports.getPropertyMetadataFromAst = exports.ONE_NS = exports.FORCE_NS = exports.LIGHTNING_NS = void 0;
-const t = __importStar(require("@babel/types"));
+exports.getFilepathSegments = exports.addPropertyFunction = exports.updateKomaciDocumentWithValidTemplatedStrings = exports.updateKomaciDocumentWithValidGetters = exports.isDeclaredInAst = exports.isExpressionThisOrAlias = exports.getThisAliasDeclaredInGetter = exports.isPropertyNodeUsed = exports.isGetterNodeUsed = exports.isPropertyUsed = exports.getClassMethodName = exports.getVariablesDeclaredInGetter = exports.isExternalModule = exports.getAstContextObject = exports.getAllClassMethods = exports.getAllModuleVaraibles = exports.getAllModuleFunctions = exports.getFromIdentifierOrStringLiteral = exports.collectImportUsage = exports.getMemberVarsFromGetter = exports.implicitConsumptionMetadata = exports.getPropertyMetadataFromAst = exports.TEMPLATED_STRING_FUNCTION = exports.GETTER_FUNCTION = exports.ONE_NS = exports.FORCE_NS = exports.LIGHTNING_NS = void 0;
 const core_1 = require("@babel/core");
-const allowlistNamespaces_1 = require("./allowlistNamespaces");
+const types_1 = require("./types");
 exports.LIGHTNING_NS = 'lightning';
 exports.FORCE_NS = 'force';
 exports.ONE_NS = 'one';
+exports.GETTER_FUNCTION = 'GetterFunction';
+exports.TEMPLATED_STRING_FUNCTION = 'TemplatedStringFunction';
 /**
  * collect node paths for different pieces of a given class so we can more effectively traverse them in the future
  *
@@ -71,80 +53,6 @@ function getPropertyMetadataFromAst(ast) {
     return nodes;
 }
 exports.getPropertyMetadataFromAst = getPropertyMetadataFromAst;
-/**
- * @param node
- * @returns true if node is a ClassBody
- */
-function isNodeClassBody(node) {
-    return node?.type === 'ClassBody';
-}
-/**
- * Given the AST of an entire JS source file, this method looks for class member properties.
- * If there is no default export in the AST, no class properties will be returned (empty array is returned).
- * @param astRoot AST representing an entire Program, as a @babel/types File object
- * @returns Array of NodePath<ClassProperty> representing the @babel NodePaths for all class member
- *          properties, if any exist. Otherwise, returns an empty array.
- */
-function getClassProperties(astRoot) {
-    let classProperties = [];
-    const prog = astRoot.program;
-    const body = prog.body;
-    const exportDefaultDecl = body.filter((child) => child.type === 'ExportDefaultDeclaration');
-    if (exportDefaultDecl.length > 0) {
-        const classDecl = exportDefaultDecl[0]
-            .declaration; // there can only be one export default declaration
-        if (isNodeClassBody(classDecl.body)) {
-            const classBody = classDecl.body;
-            classProperties = classBody.body.filter((classChild) => classChild.type === 'ClassProperty' ||
-                (classChild.type === 'ClassMethod' && classChild.kind === 'get'));
-        }
-    }
-    return classProperties;
-}
-exports.getClassProperties = getClassProperties;
-/**
- * Utility method that takes in an @babel/types ClassProperty array, and returns an array of ClassPropertyInfo
- * objects containing information about each ClassProperty from the input array.
- * @param classProperties
- * @returns Array of ClassPropertyInfo, where each element corresponds to the input ClassProperty array.
- */
-function getClassPropertyInfos(classProperties = []) {
-    const classPropInfos = [];
-    classProperties
-        .filter((classProp) => t.isIdentifier(classProp.key))
-        .forEach((classProp) => {
-        const id = classProp.key;
-        const decorators = classProp.decorators;
-        let decoratorType = undefined;
-        if (decorators) {
-            // non-annotated class properties won't have a decorator
-            const expr = decorators[0].expression;
-            if (expr.type === 'CallExpression') {
-                const callee = expr.callee;
-                decoratorType = callee.name;
-            }
-            else if (expr.type === 'Identifier') {
-                decoratorType = expr.name;
-            }
-        }
-        const classPropInfo = {
-            classProp: classProp,
-            classPropId: id.name,
-            isDecorated: decorators !== undefined &&
-                decorators !== null &&
-                decorators.length > 0,
-            hasInitialValue: t.isClassProperty(classProp)
-                ? classProp.value !== null
-                : false,
-        };
-        if (classPropInfo.isDecorated) {
-            classPropInfo.decoratorType = decoratorType;
-        }
-        classPropInfos.push(classPropInfo);
-    });
-    return classPropInfos;
-}
-exports.getClassPropertyInfos = getClassPropertyInfos;
 /**
  * Given a valid functional node (tempalte string or getter function), collect information that we may not have been able to collect via KomaciDocument
  * and return a list of class member variables that are properly used in the method body.
@@ -159,8 +67,7 @@ exports.getClassPropertyInfos = getClassPropertyInfos;
  * @returns ImplicitConsumption, which contains an array representing the properly-used member variables.
  *          Returns ImplicitConsumption with an empty array if none were found.
  */
-function implicitConsumptionMetadata(node, classPropInfos, importDeclarations, // import metadata
-moduleLevelConsumption) {
+function implicitConsumptionMetadata(node, adgIndex, moduleMetadata) {
     const identifiers = new Set();
     const Visitors = {
         // visitor for each type
@@ -168,7 +75,9 @@ moduleLevelConsumption) {
             getMemberVarsFromGetter(path, identifiers);
         },
         Identifier(path) {
-            collectImportUsage(path, classPropInfos, importDeclarations, moduleLevelConsumption.consumedImports);
+            collectImportUsage(path, moduleMetadata, 
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            moduleMetadata.adgs.get(adgIndex).properties);
         },
     };
     node.traverse(Visitors);
@@ -202,61 +111,32 @@ exports.getMemberVarsFromGetter = getMemberVarsFromGetter;
  * @param consumedImports The map to add info to about this identifier, whether it is an import that is being used
  *                        in the getter, or if it is assigned an import being used in the getter.
  */
-function collectImportUsage(path, classPropInfos, importDeclarations, consumedImports) {
-    const name = path.node.name;
-    let nameToReference = name;
-    let importInfo = importDeclarations.get(name); // finds direct references of import specifiers in the getter
-    // i.e. find `MyID1.CONST` in the getter, where `MyID1` is an import specifier
-    if (!importInfo &&
-        path.parent.type === 'MemberExpression' &&
-        path.parent.object.type === 'Identifier' &&
-        path.parent.object === path.node) {
-        importInfo = importDeclarations.get(path.parent.object.name);
-    }
-    // find indirect import references (where import was assigned to a class member variable)
-    if (!importInfo) {
-        const importSpecifierNames = new Set(Array.from(importDeclarations.keys()));
-        classPropInfos.forEach((classPropInfo) => {
-            // check for type NodePath<t.ClassProperty> vs. t.ClassProperty. The former has a .node property
-            const isNodePath = classPropInfo.classProp.node !== undefined;
-            const classProp = isNodePath
-                ? classPropInfo.classProp.node
-                : classPropInfo.classProp;
-            if (classProp.key.type === 'Identifier' &&
-                classProp.key.name === name &&
-                classProp.value?.type === 'Identifier' &&
-                importSpecifierNames.has(classProp.value.name)) {
-                importInfo = importDeclarations.get(classProp.value.name);
+function collectImportUsage(path, moduleMetadata, properties) {
+    if (path.parent.type === 'MemberExpression' &&
+        path.parent.object.type === 'ThisExpression' &&
+        path.parent.property.type === 'Identifier') {
+        const identifier = path.parent.property;
+        const referencedProperty = properties.get(identifier.name);
+        if (referencedProperty && referencedProperty.inital?.type === 'ImportReference') {
+            const importMetadata = moduleMetadata.importsByName.get(moduleMetadata.importIndexReference.get(referencedProperty.inital.value) || '');
+            if (importMetadata) {
+                importMetadata.usedInPriming = true;
             }
-        });
-    }
-    if (importInfo) {
-        if (importInfo.isDefault) {
-            nameToReference = 'default';
         }
-        else if (importInfo.isNamespaceSpecifier) {
-            // this case needs to be handled separately as it always has an alias
-            nameToReference = '*';
-        }
-        else if (importInfo.trueName) {
-            nameToReference = importInfo.trueName;
-        }
-        let fullImportContext = consumedImports.get(importInfo.namespace);
-        if (fullImportContext && !fullImportContext.names.has(name)) {
-            fullImportContext.names.add(nameToReference);
+    }
+    else {
+        const name = path.node.name;
+        let importInfo = moduleMetadata.importsByName.get(name); // finds direct references of import specifiers in the getter
+        // i.e. find `MyID1.CONST` in the getter, where `MyID1` is an import specifier
+        if (!importInfo &&
+            path.parent.type === 'MemberExpression' &&
+            path.parent.object.type === 'Identifier' &&
+            path.parent.object === path.node) {
+            importInfo = moduleMetadata.importsByName.get(path.parent.object.name);
         }
-        else if (!fullImportContext) {
-            const names = new Set();
-            names.add(nameToReference);
-            fullImportContext = {
-                names,
-                resourceName: importInfo.namespace,
-                isNamespaceSpecifier: importInfo.isNamespaceSpecifier,
-                isDefaultSpecifier: importInfo.isDefault,
-                isSupported: importInfo.isSupported,
-            };
+        if (importInfo) {
+            importInfo.usedInPriming = true;
         }
-        consumedImports.set(importInfo.namespace, fullImportContext);
     }
 }
 exports.collectImportUsage = collectImportUsage;
@@ -270,53 +150,6 @@ function getFromIdentifierOrStringLiteral(node) {
     return node.type === 'Identifier' ? node.name : node.value;
 }
 exports.getFromIdentifierOrStringLiteral = getFromIdentifierOrStringLiteral;
-/**
- * Function for getting an array of supported namesapce references.
- * @param astRoot the root of the ast
- * @returns an Array of supported namespace references.
- */
-function getAllImportReferences(astRoot) {
-    const importReferences = new Map();
-    const program = astRoot.program;
-    const body = program.body;
-    const importDeclarations = body.filter((currentDec) => currentDec.type === 'ImportDeclaration');
-    importDeclarations.forEach((currentDec) => {
-        const isValid = isValidNamespace(currentDec.source.value) &&
-            (0, allowlistNamespaces_1.isLibraryValid)(currentDec.source.value);
-        const specifiers = currentDec.specifiers;
-        specifiers.forEach((currentSpecifier) => {
-            let importName = undefined;
-            if (currentSpecifier.type === 'ImportSpecifier') {
-                importName = currentSpecifier.local // local is alias (the most specific name)
-                    ? getFromIdentifierOrStringLiteral(currentSpecifier.local)
-                    : getFromIdentifierOrStringLiteral(currentSpecifier.imported);
-            }
-            else {
-                importName = getFromIdentifierOrStringLiteral(currentSpecifier.local);
-            }
-            importReferences.set(importName, {
-                namespace: currentDec.source.value,
-                identifierName: importName,
-                isSupported: isValid,
-                isDefault: currentSpecifier.type === 'ImportDefaultSpecifier',
-                isNamespaceSpecifier: currentSpecifier.type === 'ImportNamespaceSpecifier',
-                trueName: currentSpecifier.type === 'ImportSpecifier'
-                    ? getFromIdentifierOrStringLiteral(currentSpecifier.imported)
-                    : undefined,
-            });
-        });
-    });
-    return importReferences;
-}
-exports.getAllImportReferences = getAllImportReferences;
-/**
- * Helper function to validate if a namespace is in our allowed namespace list.
- * @param namespace the namespace to validate.
- * @returns true of the namespace is supported, false if unsupported.
- */
-function isValidNamespace(importPath) {
-    return (0, allowlistNamespaces_1.isNamespaceInternal)((0, allowlistNamespaces_1.getNamespaceFromImport)(importPath));
-}
 /**
  * Function to get an array of function names that are defined at the module level.
  * @returns an array of function names that are defined at the module level.
@@ -414,12 +247,9 @@ exports.getAllClassMethods = getAllClassMethods;
  * @returns a context object containing meta data about the ast.
  */
 function getAstContextObject(ast) {
-    const props = getClassProperties(ast);
     const context = {
-        importDeclarations: getAllImportReferences(ast),
         moduleFunctions: getAllModuleFunctions(ast),
         moduleVariables: getAllModuleVaraibles(ast),
-        classProperties: getClassPropertyInfos(props),
         classFunctions: getAllClassMethods(ast),
     };
     return context;
@@ -543,12 +373,136 @@ exports.isExpressionThisOrAlias = isExpressionThisOrAlias;
  * @param declaredGetterVars a collection of variables declared within the getter
  * @param id the id of the member we are referencing.
  */
-function isDeclaredInAst(astContext, declaredGetterVars, id) {
-    const { classProperties, importDeclarations, moduleVariables } = astContext;
-    return (classProperties.find((prop) => prop.classPropId === id) !== undefined ||
+function isDeclaredInAst(astContext, importDeclarations, classProperties, declaredGetterVars, id) {
+    const { moduleVariables } = astContext;
+    return (classProperties.has(id) ||
         importDeclarations.has(id) ||
         moduleVariables.find((varId) => varId === id) !== undefined ||
         (declaredGetterVars || []).find((varId) => varId === id) !== undefined);
 }
 exports.isDeclaredInAst = isDeclaredInAst;
+/**
+ * Function to update the Komaci Document with validated getter information. This function will update the functions array in the
+ * export default adg along with the property references in the property array.
+ * @param komaciScriptDoc the komaci document
+ * @param validGetterContext a collection
+ */
+function updateKomaciDocumentWithValidGetters(komaciScriptDoc, validGetterContext) {
+    if (komaciScriptDoc.exports) {
+        //get the exort mapping for the export default
+        const defaultExportMapping = komaciScriptDoc.exports['default'];
+        if (defaultExportMapping && defaultExportMapping.type === 'AdgReference') {
+            const defaultExportAdg = komaciScriptDoc.adgs?.[defaultExportMapping.value];
+            //foreach getter in the context.
+            validGetterContext.forEach((getter) => {
+                //Get the name of the getter.
+                const getterName = getter.getter.node.key.name;
+                const inputArr = {
+                    type: 'ArrayValue',
+                    value: [],
+                };
+                getter.memberUsage.forEach((member) => {
+                    const primVal = {
+                        type: 'PrimitiveValue',
+                        value: member,
+                    };
+                    inputArr.value.push(primVal);
+                });
+                //create a new functionType obj with getter information.
+                const validGetterFunction = {
+                    type: exports.GETTER_FUNCTION,
+                    reference: { type: 'InternalReference', value: getter.generatedName },
+                    input: [inputArr],
+                    location: undefined,
+                };
+                //if we have an adg make changes to it.
+                if (defaultExportAdg) {
+                    getter.f_index = addPropertyFunction(defaultExportAdg, getterName, validGetterFunction);
+                }
+            });
+        }
+    }
+}
+exports.updateKomaciDocumentWithValidGetters = updateKomaciDocumentWithValidGetters;
+/**
+ * Function to update the Komaci Document with validated template information. This function will update the functions array in the
+ * export default adg along with the property references in the property array.
+ * @param komaciScriptDoc the komaci document
+ * @param ValidTemplateContext details about the templates we've deemed to be valid
+ */
+function updateKomaciDocumentWithValidTemplatedStrings(komaciScriptDoc, templateStrings) {
+    if (komaciScriptDoc.exports?.default?.type === 'AdgReference') {
+        const adg = komaciScriptDoc.adgs?.[komaciScriptDoc.exports.default.value];
+        if (adg) {
+            templateStrings.forEach((template) => {
+                const propertyName = template.template.node.key.name;
+                const inputArr = {
+                    type: 'ArrayValue',
+                    value: [],
+                };
+                template.memberUsage.forEach((member) => {
+                    const primVal = {
+                        type: 'PrimitiveValue',
+                        value: member,
+                    };
+                    inputArr.value.push(primVal);
+                });
+                const validTemplateStringFunction = {
+                    type: exports.TEMPLATED_STRING_FUNCTION,
+                    reference: {
+                        type: 'InternalReference',
+                        value: template.generatedName,
+                    },
+                    input: [inputArr],
+                    location: undefined,
+                };
+                //if we have an adg make changes to it.
+                if (adg) {
+                    template.f_index = addPropertyFunction(adg, propertyName, validTemplateStringFunction);
+                }
+            });
+        }
+    }
+}
+exports.updateKomaciDocumentWithValidTemplatedStrings = updateKomaciDocumentWithValidTemplatedStrings;
+/**
+ * Update the functions array with the newly formed function reference and point the property to it
+ * @param adg The adg to update
+ * @param propertyName name of the property to update
+ */
+function addPropertyFunction(adg, propertyName, func) {
+    if (!adg.functions) {
+        adg.functions = [];
+    }
+    if (!adg.properties) {
+        adg.properties = {};
+    }
+    //push getter onto array get the length.
+    const fIndex = adg.functions.push(func);
+    const refIndex = fIndex - 1;
+    //create new property to reference function array.
+    const property = {
+        isPublic: adg.properties[propertyName]?.isPublic || false,
+        input: {
+            type: 'FunctionReference',
+            value: refIndex,
+        },
+    };
+    adg.properties[propertyName] = property;
+    return refIndex;
+}
+exports.addPropertyFunction = addPropertyFunction;
+/**
+ * Function to slpit an import path seperated by . EX: ./test.html = [, /test, html ]
+ * @param fullFilename the full file name
+ * @returns the full file name separated into segments.
+ */
+function getFilepathSegments(fullFilename) {
+    const segments = fullFilename.split('.');
+    if (segments.length < 2) {
+        throw new Error(types_1.ERROR_PREFIX + 'unable to determine file type');
+    }
+    return segments;
+}
+exports.getFilepathSegments = getFilepathSegments;
 //# sourceMappingURL=utils.js.map

package/build/wires.d.ts

@@ -0,0 +1,12 @@
+import { GetPrimingAdapter } from './types';
+/**
+ * Determine whether the wire adapter is supported
+ * @param resourceName the resource name of the Import, as a string
+ * @param adapterName the wire adapter variable name (import specifier export name) from a single
+ *                    Import statement (which can have more than one of these export names)
+ * @returns boolean true if the adapterName represents is a supported wire adapter (note that some
+ *          resourceNames allow any adapterName as valid wire adapters)
+ */
+export declare function isSupportedWireAdapter(resourceName: string | undefined, adapterName: string | undefined): boolean;
+export declare const getPrimingAdapter: GetPrimingAdapter;
+//# sourceMappingURL=wires.d.ts.map

package/build/wires.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrimingAdapter = exports.isSupportedWireAdapter = void 0;
+const adaptersMapping_1 = require("./adaptersMapping");
+const allowlistAdapters_1 = require("./allowlistAdapters");
+/**
+ * Determine whether the wire adapter is supported
+ * @param resourceName the resource name of the Import, as a string
+ * @param adapterName the wire adapter variable name (import specifier export name) from a single
+ *                    Import statement (which can have more than one of these export names)
+ * @returns boolean true if the adapterName represents is a supported wire adapter (note that some
+ *          resourceNames allow any adapterName as valid wire adapters)
+ */
+function isSupportedWireAdapter(resourceName, adapterName) {
+    if (!resourceName || !adapterName) {
+        return false;
+    }
+    // check if the resourceName is one of the types that can have any wire adapter name. If so, return true.
+    // allow list of ResourceName that can be a "starsWith" match
+    for (const allowedResourceNamePrefix of allowlistAdapters_1.allowlistResourceNamesStartsWith) {
+        if (resourceName.startsWith(allowedResourceNamePrefix)) {
+            return true;
+        }
+    }
+    // allow list of ResourceNames that need to be an exact match
+    for (const allowedResourceName of allowlistAdapters_1.allowlistResourceNamesExact) {
+        if (resourceName === allowedResourceName) {
+            return true;
+        }
+    }
+    // check the allowlist of wire adapters for certain various resourceNames that all start with "lightning".
+    for (const [resourceNameKey, adapterList] of Object.entries(allowlistAdapters_1.allowlistAdapters)) {
+        if (resourceNameKey === resourceName && adapterList.includes(adapterName)) {
+            return true;
+        }
+    }
+    // check if there's an associated LDS priming adapter.
+    if ((0, exports.getPrimingAdapter)(resourceName, adapterName)) {
+        return true;
+    }
+    return false;
+}
+exports.isSupportedWireAdapter = isSupportedWireAdapter;
+const getPrimingAdapter = (importPath, identifier) => {
+    const adapterMap = adaptersMapping_1.wireAdaptersMap[importPath];
+    if (adapterMap === undefined) {
+        return null;
+    }
+    const primingAdapter = adapterMap[identifier];
+    if (primingAdapter === undefined) {
+        return null;
+    }
+    return primingAdapter;
+};
+exports.getPrimingAdapter = getPrimingAdapter;
+//# sourceMappingURL=wires.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@komaci/common-shared",
-    "version": "240.1.5",
+    "version": "242.1.1",
     "description": "Assets that are shared across Komaci commonjs packages",
     "homepage": "https://komaci.dev/",
     "repository": {
@@ -25,10 +25,11 @@
     "files": [
         "build/**/*.js",
         "build/**/*.d.ts",
-        "build/internal-namespaces.json"
+        "build/internal-namespaces.json",
+        "build/komaci-mapping.json"
     ],
     "devDependencies": {
-        "@komaci/types": "240.1.5"
+        "@komaci/types": "242.1.1"
     },
     "dependencies": {
         "@babel/core": "^7.9.0",