@komaci/static-analyzer 240.1.3

package/build/WireGraph.d.ts

@@ -0,0 +1,34 @@
+import { WireInfo } from './types';
+/**
+ * Class that represent a WireInfo graph of a wire dependencies. This data structure is needed to detect dependency cycles,
+ * so that they can be reported to the user as a PrimingDiagnostic
+ */
+export declare class WireGraph {
+    private vertices;
+    private wireWithCycle;
+    private cycleVertices;
+    constructor(vertices?: Array<WireInfo>);
+    /**
+     * Detects a cycle in the directed WireGraph, even if it is disconnected graph (we can't reach all nodes from any one node)
+     * @returns true if cycle is detected in this directed WireGraph, false otherwise
+     */
+    hasCycle(): boolean;
+    private hasCycleInternal;
+    /**
+     * Gets the wire whose child results in a cycle in the graph.
+     * @returns WireInfo if a cycle was detected, undefined otherwise
+     */
+    getWireThatCycles(): WireInfo | undefined;
+    /**
+     * Returns the top of the "stack" which has the first dependency in the dependency chain
+     * @returns name of the property that starts the dependency chain, which we can include in the error message,
+     *          or blank string if the stack if empty (no cycle found)
+     */
+    getWireCycleProperty(): string;
+    /**
+     * Returns the dependency chain as a string
+     * @returns string representing the wire configuration dependency chain
+     */
+    getWireCycleString(): string;
+}
+//# sourceMappingURL=WireGraph.d.ts.map

package/build/WireGraph.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WireGraph = void 0;
+/**
+ * Class that represent a WireInfo graph of a wire dependencies. This data structure is needed to detect dependency cycles,
+ * so that they can be reported to the user as a PrimingDiagnostic
+ */
+class WireGraph {
+    constructor(vertices = []) {
+        this.cycleVertices = [];
+        this.vertices = vertices;
+    }
+    /**
+     * Detects a cycle in the directed WireGraph, even if it is disconnected graph (we can't reach all nodes from any one node)
+     * @returns true if cycle is detected in this directed WireGraph, false otherwise
+     */
+    hasCycle() {
+        for (const vertex of this.vertices) {
+            if (!vertex.visited && this.hasCycleInternal(vertex)) {
+                return true;
+            }
+        }
+        this.wireWithCycle = undefined;
+        return false;
+    }
+    hasCycleInternal(sourceWire) {
+        sourceWire.beingVisited = true;
+        for (const wire of sourceWire.dependentWires) {
+            if (wire.beingVisited) {
+                this.wireWithCycle = wire; // track wire whose child resulted in a cycle detection
+                if (wire.propName) {
+                    this.cycleVertices.push(wire.propName); // track traversal so we can print out dependency chain later
+                }
+                return true; // backward edge exists, cycle detected (base case, return from recursive calls)
+            }
+            else if (!wire.visited && this.hasCycleInternal(wire)) {
+                // DFS recursion of child
+                if (wire.propName) {
+                    this.cycleVertices.push(wire.propName); // track traversal so we can print out dependency chain later
+                }
+                return true;
+            }
+        }
+        sourceWire.beingVisited = false;
+        sourceWire.visited = true;
+        return false;
+    }
+    /**
+     * Gets the wire whose child results in a cycle in the graph.
+     * @returns WireInfo if a cycle was detected, undefined otherwise
+     */
+    getWireThatCycles() {
+        return this.wireWithCycle;
+    }
+    /**
+     * Returns the top of the "stack" which has the first dependency in the dependency chain
+     * @returns name of the property that starts the dependency chain, which we can include in the error message,
+     *          or blank string if the stack if empty (no cycle found)
+     */
+    getWireCycleProperty() {
+        return this.cycleVertices.length > 0
+            ? this.cycleVertices[this.cycleVertices.length - 1]
+            : '';
+    }
+    /**
+     * Returns the dependency chain as a string
+     * @returns string representing the wire configuration dependency chain
+     */
+    getWireCycleString() {
+        let wireCycleString = '';
+        const lastIndex = this.cycleVertices.length - 1;
+        for (let index = lastIndex; index >= 0; index -= 1) {
+            wireCycleString += this.cycleVertices[index] + '->';
+            if (index == 0) {
+                wireCycleString += this.cycleVertices[lastIndex];
+            }
+        }
+        return wireCycleString;
+    }
+}
+exports.WireGraph = WireGraph;
+//# sourceMappingURL=WireGraph.js.map

package/build/__mocks__/@babel/parser.d.ts

@@ -0,0 +1,2 @@
+export declare const parse: any;
+//# sourceMappingURL=parser.d.ts.map

package/build/__mocks__/@babel/parser.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const { parse: actualParse } = jest.requireActual('@babel/parser');
+exports.parse = actualParse;
+//# sourceMappingURL=parser.js.map

package/build/adaptersMapping.d.ts

@@ -0,0 +1,3 @@
+import { WireAdaptersMapping } from './types';
+export declare const wireAdaptersMap: WireAdaptersMapping;
+//# sourceMappingURL=adaptersMapping.d.ts.map

package/build/adaptersMapping.js

@@ -0,0 +1,25 @@
+"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.wireAdaptersMap = void 0;
+const wireAdapterImport = __importStar(require("./komaci-mapping.json"));
+exports.wireAdaptersMap = wireAdapterImport;
+//# sourceMappingURL=adaptersMapping.js.map

package/build/allowlistAdapters.d.ts

@@ -0,0 +1,6 @@
+export declare const allowlistAdapters: {
+    [key: string]: string[];
+};
+export declare const allowlistResourceNamesStartsWith: string[];
+export declare const allowlistResourceNamesExact: string[];
+//# sourceMappingURL=allowlistAdapters.d.ts.map

package/build/allowlistAdapters.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allowlistResourceNamesExact = exports.allowlistResourceNamesStartsWith = exports.allowlistAdapters = void 0;
+exports.allowlistAdapters = {
+    'lightning/navigation': ['CurrentPageReference'],
+}; // these must match the resourceName and one or more of the wire adapter names (export names), exactly
+// these can have any wire adapter name (export name)
+exports.allowlistResourceNamesStartsWith = ['@salesforce/apex']; // resourceName can start with
+exports.allowlistResourceNamesExact = ['laf/transformWire']; // resourceName must exactly match this
+//# sourceMappingURL=allowlistAdapters.js.map

package/build/index.d.ts

@@ -0,0 +1,7 @@
+import { AnalyzerInput, PrimingDiagnostic } from './types';
+export declare function generatePrimingDiagnosticsModule(input: AnalyzerInput): PrimingDiagnostic[];
+export { AnalyzerInput, PrimingDiagnostic, Range, Position, PrimingAdapterDefinition, } from './types';
+export { getPrimingAdapter, isSupportedNamespace, isSupportedWireAdapter, isImageComposition, } from './shared';
+export { diagnosticMessages, getPrimingDiagnostic } from './rules';
+export * from './validateGetter';
+//# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -0,0 +1,35 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrimingDiagnostic = exports.diagnosticMessages = exports.isImageComposition = exports.isSupportedWireAdapter = exports.isSupportedNamespace = exports.getPrimingAdapter = exports.generatePrimingDiagnosticsModule = void 0;
+const staticAnalyzer_1 = require("./staticAnalyzer");
+function generatePrimingDiagnosticsModule(input) {
+    const analyzer = new staticAnalyzer_1.StaticAnalyzer();
+    if (input.type === 'bundle') {
+        return analyzer.analyzeBundle(input);
+    }
+    if (input.type === 'file') {
+        return analyzer.analyzeScript(input);
+    }
+    throw new Error('input type was neither file or bundle');
+}
+exports.generatePrimingDiagnosticsModule = generatePrimingDiagnosticsModule;
+var shared_1 = require("./shared");
+Object.defineProperty(exports, "getPrimingAdapter", { enumerable: true, get: function () { return shared_1.getPrimingAdapter; } });
+Object.defineProperty(exports, "isSupportedNamespace", { enumerable: true, get: function () { return shared_1.isSupportedNamespace; } });
+Object.defineProperty(exports, "isSupportedWireAdapter", { enumerable: true, get: function () { return shared_1.isSupportedWireAdapter; } });
+Object.defineProperty(exports, "isImageComposition", { enumerable: true, get: function () { return shared_1.isImageComposition; } });
+var rules_1 = require("./rules");
+Object.defineProperty(exports, "diagnosticMessages", { enumerable: true, get: function () { return rules_1.diagnosticMessages; } });
+Object.defineProperty(exports, "getPrimingDiagnostic", { enumerable: true, get: function () { return rules_1.getPrimingDiagnostic; } });
+__exportStar(require("./validateGetter"), exports);
+//# sourceMappingURL=index.js.map

package/build/invariantFunctions/assignmentExpressionInvariantFunctions.d.ts

@@ -0,0 +1,16 @@
+import { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { PrimingDiagnostic } from '../types';
+/**
+ * Invariant function for checking if a member variable get a value assigned to it.
+ * @param path the babel path object for the current Assignment Expressoin.
+ * @returns undefined if NO member variable is assigned a value, location object if a member variable is assigned a value.
+ */
+export declare function checkForNoMemberVariableAssignments(path: NodePath<t.AssignmentExpression>): PrimingDiagnostic | undefined;
+/**
+ * Function to check external components for an Assignment Expression.
+ * @param path the node path for an assignemnt expression
+ * @returns a PrimingDiagnostic if there is an Assignment Expression, undefined if not.
+ */
+export declare function checkExternalComponentForAssignmentExpr(path: NodePath<t.AssignmentExpression>): PrimingDiagnostic | undefined;
+//# sourceMappingURL=assignmentExpressionInvariantFunctions.d.ts.map

package/build/invariantFunctions/assignmentExpressionInvariantFunctions.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkExternalComponentForAssignmentExpr = exports.checkForNoMemberVariableAssignments = void 0;
+const rules_1 = require("../rules");
+const shared_1 = require("../shared");
+/**
+ * Invariant function for checking if a member variable get a value assigned to it.
+ * @param path the babel path object for the current Assignment Expressoin.
+ * @returns undefined if NO member variable is assigned a value, location object if a member variable is assigned a value.
+ */
+function checkForNoMemberVariableAssignments(path) {
+    const assignmentExpr = path.node;
+    const leftNode = assignmentExpr.left;
+    if (leftNode.object?.type === 'ThisExpression') {
+        if (leftNode.loc !== null) {
+            return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_ASSIGNMENT_EXPRESSION_ASSIGNS_VALUE_TO_MEMBER_VARIABLE, shared_1.LLSRange.fromBabelSourceLocation(leftNode.loc), [leftNode.property.name]);
+        }
+    }
+    return undefined;
+}
+exports.checkForNoMemberVariableAssignments = checkForNoMemberVariableAssignments;
+/**
+ * Function to check external components for an Assignment Expression.
+ * @param path the node path for an assignemnt expression
+ * @returns a PrimingDiagnostic if there is an Assignment Expression, undefined if not.
+ */
+function checkExternalComponentForAssignmentExpr(path) {
+    const assignmentExpr = path.node;
+    if (assignmentExpr.loc !== null) {
+        return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_ASSIGNMENT_EXPRESSION_FOR_EXTERNAL_COMPONENTS, shared_1.LLSRange.fromBabelSourceLocation(assignmentExpr.loc), []);
+    }
+}
+exports.checkExternalComponentForAssignmentExpr = checkExternalComponentForAssignmentExpr;
+//# sourceMappingURL=assignmentExpressionInvariantFunctions.js.map

package/build/invariantFunctions/callExpressionInvariantFunctions.d.ts

@@ -0,0 +1,33 @@
+import { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { PrimingDiagnostic } from '../types';
+import { ImportDeclarationInfo } from '@komaci/common-shared';
+/**
+ * Invariant function for checking if call expressions references an unsupported import.
+ * @param path the babel path object for the current call expression.
+ * @param importReferences a set of supported import references.
+ * @returns undefined if a call expression does NOT reference an unspoorted import, locatoin object if a call expression references an unsupported import.
+ */
+export declare function checkCallExpressionForNonSupportedNamespaceRefs(path: NodePath<t.CallExpression>, importReferences: Map<string, ImportDeclarationInfo>): PrimingDiagnostic | undefined;
+/**
+ * Validates whether a CallExpression Node on the AST adheres to a portability invariant (whether it doesn't
+ * contain 'eval()' call).
+ * @param path NodePath<CallExpression> containing a CallExpression to analyze for the invariant
+ * @returns PrimingDiagnostic of the CallExpression if an invariant is detected, or undefined if none was found
+ */
+export declare function checkNoUsageOfEval(path: NodePath<t.CallExpression>): PrimingDiagnostic | undefined;
+/**
+ * Function that checks if there are any references to other functions that are defined on the class.
+ * @param path the current call expression node.
+ * @param classFunctions a collection of function names that are defined on the class.
+ * @returns {PrimingDiagnostic} a PrimingDiagnostic if there is a reference to another class function, undefined if no reference.
+ */
+export declare function checkForNoReferenceToClassFunctions(path: NodePath<t.CallExpression>, classFunctions: string[]): PrimingDiagnostic | undefined;
+/**
+ * Function that checks if there are any references to other functions that are defined on the module.
+ * @param path the current call expression node.
+ * @param classFunctions a collection of function names that are defined on the module.
+ * @returns PrimingDiagnostic object if there is a reference to another module function, undefined if no reference.
+ */
+export declare function checkForNoReferenceToModuleFunctions(path: NodePath<t.CallExpression>, moduleFunctions: string[]): PrimingDiagnostic | undefined;
+//# sourceMappingURL=callExpressionInvariantFunctions.d.ts.map

package/build/invariantFunctions/callExpressionInvariantFunctions.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForNoReferenceToModuleFunctions = exports.checkForNoReferenceToClassFunctions = exports.checkNoUsageOfEval = exports.checkCallExpressionForNonSupportedNamespaceRefs = void 0;
+const shared_1 = require("../shared");
+const rules_1 = require("../rules");
+/**
+ * Invariant function for checking if call expressions references an unsupported import.
+ * @param path the babel path object for the current call expression.
+ * @param importReferences a set of supported import references.
+ * @returns undefined if a call expression does NOT reference an unspoorted import, locatoin object if a call expression references an unsupported import.
+ */
+function checkCallExpressionForNonSupportedNamespaceRefs(path, importReferences) {
+    const callExprNode = path.node;
+    const callee = callExprNode.callee;
+    if (importReferences.get(callee.name)) {
+        if (!importReferences.get(callee.name)?.isSupported) {
+            if (callee.loc != null) {
+                return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_CALL_EXPRESSION_REFERENCES_UNSUPPORTED_NAMESPACE, shared_1.LLSRange.fromBabelSourceLocation(callee.loc), [callee.name]);
+            }
+        }
+    }
+    return undefined;
+}
+exports.checkCallExpressionForNonSupportedNamespaceRefs = checkCallExpressionForNonSupportedNamespaceRefs;
+/**
+ * Validates whether a CallExpression Node on the AST adheres to a portability invariant (whether it doesn't
+ * contain 'eval()' call).
+ * @param path NodePath<CallExpression> containing a CallExpression to analyze for the invariant
+ * @returns PrimingDiagnostic of the CallExpression if an invariant is detected, or undefined if none was found
+ */
+function checkNoUsageOfEval(path) {
+    const callExpr = path.node;
+    if (callExpr.callee.type === 'Identifier' && callExpr.callee.name === 'eval') {
+        if (callExpr.callee.loc !== null) {
+            return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_EVAL_USAGE, shared_1.LLSRange.fromBabelSourceLocation(callExpr.callee.loc), [callExpr.callee.name]);
+        }
+    }
+    return undefined;
+}
+exports.checkNoUsageOfEval = checkNoUsageOfEval;
+/**
+ * Function that checks if there are any references to other functions that are defined on the class.
+ * @param path the current call expression node.
+ * @param classFunctions a collection of function names that are defined on the class.
+ * @returns {PrimingDiagnostic} a PrimingDiagnostic if there is a reference to another class function, undefined if no reference.
+ */
+function checkForNoReferenceToClassFunctions(path, classFunctions) {
+    const callExpr = path.node;
+    if (callExpr.callee.type === 'MemberExpression') {
+        const memberExpr = callExpr.callee;
+        if (memberExpr.object.type === 'ThisExpression') {
+            if (memberExpr.object.loc !== null) {
+                return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_REFERENCE_TO_CLASS_FUNCTIONS, shared_1.LLSRange.fromBabelSourceLocation(memberExpr.object.loc), [memberExpr.property.name]);
+            }
+        }
+    }
+    if (callExpr.callee.type === 'Identifier') {
+        const identifier = callExpr.callee;
+        if (classFunctions.includes(identifier.name)) {
+            if (callExpr.callee.loc !== null) {
+                return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_REFERENCE_TO_CLASS_FUNCTIONS, shared_1.LLSRange.fromBabelSourceLocation(callExpr.callee.loc), [callExpr.callee.name]);
+            }
+        }
+    }
+    return undefined;
+}
+exports.checkForNoReferenceToClassFunctions = checkForNoReferenceToClassFunctions;
+/**
+ * Function that checks if there are any references to other functions that are defined on the module.
+ * @param path the current call expression node.
+ * @param classFunctions a collection of function names that are defined on the module.
+ * @returns PrimingDiagnostic object if there is a reference to another module function, undefined if no reference.
+ */
+function checkForNoReferenceToModuleFunctions(path, moduleFunctions) {
+    const callExpr = path.node;
+    if (callExpr.callee.type === 'Identifier') {
+        const identifier = callExpr.callee;
+        if (moduleFunctions.includes(identifier.name)) {
+            if (callExpr.callee.loc !== null) {
+                return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_REFERENCE_TO_MODULE_FUNCTIONS, shared_1.LLSRange.fromBabelSourceLocation(callExpr.callee.loc), [callExpr.callee.name]);
+            }
+        }
+    }
+    return undefined;
+}
+exports.checkForNoReferenceToModuleFunctions = checkForNoReferenceToModuleFunctions;
+//# sourceMappingURL=callExpressionInvariantFunctions.js.map

package/build/invariantFunctions/functionExpressionInvariantFunctions.d.ts

@@ -0,0 +1,31 @@
+import { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { ModuleContext } from '@komaci/common-shared';
+import { PrimingDiagnostic } from '../types';
+/**
+ * Checks whether a getter contains an unnamed function declaration (anonymous FunctionExpression or ArrowFunctionExpression),
+ * as well named FunctionExpression, NodePaths in the AST. None of these are allowed for external components.
+ * @param {NodePath<t.FunctionExpression> | NodePath<t.ArrowFunctionExpression>} path NodePath containing a
+ *        {FunctionExpression | ArrowFunctionExpression} to analyze
+ * @returns PrimingDiagnostic of the FunctionExpression or ArrowFunctionExpression if the invariant is detected, or
+ *          undefined if none was found
+ */
+export declare function checkForFunctionExpression(path: NodePath<t.FunctionExpression> | NodePath<t.ArrowFunctionExpression>): PrimingDiagnostic | undefined;
+/**
+ * Checks for the presence of an Anonymous Function Expression or ArrowFunctionExpression in the context of an external component
+ * (where it is not allowed).
+ * @param {ModuelContext} moduleContext which can tell if we are in the context of an external component or not
+ * @param {NodePath<t.FunctionExpression> | NodePath<t.ArrowFunctionExpression>} path the NodePath of the FunctionExpression or
+ *        ArrowFunctionExpression to be evaluated
+ * @returns PrimingDiagnostic if anonymous function expression is found in the context of an external component, or undefined if none was found
+ * or if one was detected within the context of an internal component
+ */
+export declare function checkForFunctionExpressionIfExternalComponent(moduleContext: ModuleContext, path: NodePath<t.FunctionExpression> | NodePath<t.ArrowFunctionExpression>): PrimingDiagnostic | undefined;
+/**
+ * Checks whether a getter contains an named function declaration NodePath (as an ObjectMethod) on the AST
+ * @param {ModuelContext} moduleContext which can tell if we are in the context of an external component or not
+ * @param {NodePath<ObjectMethod>} path NodePath containing a {ObjectMethod} to analyze
+ * @returns PrimingDiagnostic of the first ObjectMethod invariant encountered is detected, or undefined if none was found
+ */
+export declare function checkForObjectMethodFunctionDeclarations(moduleContext: ModuleContext, path: NodePath<t.ObjectMethod>): PrimingDiagnostic | undefined;
+//# sourceMappingURL=functionExpressionInvariantFunctions.d.ts.map

package/build/invariantFunctions/functionExpressionInvariantFunctions.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForObjectMethodFunctionDeclarations = exports.checkForFunctionExpressionIfExternalComponent = exports.checkForFunctionExpression = void 0;
+const shared_1 = require("../shared");
+const rules_1 = require("../rules");
+/**
+ * Checks whether a getter contains an unnamed function declaration (anonymous FunctionExpression or ArrowFunctionExpression),
+ * as well named FunctionExpression, NodePaths in the AST. None of these are allowed for external components.
+ * @param {NodePath<t.FunctionExpression> | NodePath<t.ArrowFunctionExpression>} path NodePath containing a
+ *        {FunctionExpression | ArrowFunctionExpression} to analyze
+ * @returns PrimingDiagnostic of the FunctionExpression or ArrowFunctionExpression if the invariant is detected, or
+ *          undefined if none was found
+ */
+function checkForFunctionExpression(path) {
+    const expr = path.node;
+    if (expr.type === 'FunctionExpression') {
+        const funcExpr = expr;
+        if (funcExpr.id === null) {
+            if (funcExpr.loc !== null) {
+                return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_FUNCTIONS_DECLARED_WITHIN_GETTER_METHOD, shared_1.LLSRange.fromBabelSourceLocation(funcExpr.loc), []);
+            }
+        }
+        else {
+            if (funcExpr.loc !== null) {
+                return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_FUNCTIONS_DECLARED_WITHIN_GETTER_METHOD, shared_1.LLSRange.fromBabelSourceLocation(funcExpr.loc), []);
+            }
+        }
+    }
+    else if (expr.type === 'ArrowFunctionExpression') {
+        const arrowFuncExpr = expr;
+        if (arrowFuncExpr.loc !== null) {
+            return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_FUNCTIONS_DECLARED_WITHIN_GETTER_METHOD, shared_1.LLSRange.fromBabelSourceLocation(arrowFuncExpr.loc), []);
+        }
+    }
+    return undefined;
+}
+exports.checkForFunctionExpression = checkForFunctionExpression;
+/**
+ * Checks for the presence of an Anonymous Function Expression or ArrowFunctionExpression in the context of an external component
+ * (where it is not allowed).
+ * @param {ModuelContext} moduleContext which can tell if we are in the context of an external component or not
+ * @param {NodePath<t.FunctionExpression> | NodePath<t.ArrowFunctionExpression>} path the NodePath of the FunctionExpression or
+ *        ArrowFunctionExpression to be evaluated
+ * @returns PrimingDiagnostic if anonymous function expression is found in the context of an external component, or undefined if none was found
+ * or if one was detected within the context of an internal component
+ */
+function checkForFunctionExpressionIfExternalComponent(moduleContext, path) {
+    return moduleContext.isExternal ? checkForFunctionExpression(path) : undefined;
+}
+exports.checkForFunctionExpressionIfExternalComponent = checkForFunctionExpressionIfExternalComponent;
+/**
+ * Checks whether a getter contains an named function declaration NodePath (as an ObjectMethod) on the AST
+ * @param {ModuelContext} moduleContext which can tell if we are in the context of an external component or not
+ * @param {NodePath<ObjectMethod>} path NodePath containing a {ObjectMethod} to analyze
+ * @returns PrimingDiagnostic of the first ObjectMethod invariant encountered is detected, or undefined if none was found
+ */
+function checkForObjectMethodFunctionDeclarations(moduleContext, path) {
+    const objMethod = path.node;
+    if (moduleContext.isExternal) {
+        if (objMethod.type === 'ObjectMethod') {
+            if (objMethod.loc !== null) {
+                return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_FUNCTIONS_DECLARED_WITHIN_GETTER_METHOD, shared_1.LLSRange.fromBabelSourceLocation(objMethod.loc), []);
+            }
+        }
+    }
+    return undefined;
+}
+exports.checkForObjectMethodFunctionDeclarations = checkForObjectMethodFunctionDeclarations;
+//# sourceMappingURL=functionExpressionInvariantFunctions.js.map

package/build/invariantFunctions/identifierInvariantFunctions.d.ts

@@ -0,0 +1,28 @@
+import { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { ImportDeclarationInfo } from '@komaci/common-shared';
+import { PrimingDiagnostic } from '../types';
+/**
+ * Invariant function to check for no references to module varaibles.
+ * @param path the babel path for the identifier.
+ * @param moduleVars a collection of module variables.
+ * @param classVariables a collection of variables defined within the a getter.
+ * @returns a locatoin object if there are references to a module variable, undefined if not.
+ */
+export declare function checkForNoReferenceToModuleVariables(path: NodePath<t.Identifier>, moduleVars: string[], classVariables: string[]): PrimingDiagnostic | undefined;
+/**
+ * Invariant function to check if an identifier references an unsupported import.
+ *
+ * We ignore identifiers in specific usecases for this check predominantly bc of situational awareness:
+ * - Decorator parent: out of scope for this check
+ * - This Expression Parent: this.anything will never be an import ref
+ * - MemberExpression, CallExpression, TaggedTemplateExpression: similar checks done by other invariants so don't have to do them here.
+ *
+ * @param path the babel path object for the current member expression
+ * @param supportedImportRefs a set of supported import references.
+ * @param declaredVariables list of variables declared in the function to manage scoping collisions
+ * @returns undefined if a member expression does NOT reference an unsuppoerted import, PrimingDiagnostic object
+ *          if an unsupported import is reference.
+ */
+export declare function checkIdentifierForNonSupportedNamespaceRefs(path: NodePath<t.Identifier>, importReferences: Map<string, ImportDeclarationInfo>, declaredVariables: string[]): PrimingDiagnostic | undefined;
+//# sourceMappingURL=identifierInvariantFunctions.d.ts.map

package/build/invariantFunctions/identifierInvariantFunctions.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIdentifierForNonSupportedNamespaceRefs = exports.checkForNoReferenceToModuleVariables = void 0;
+const rules_1 = require("../rules");
+const shared_1 = require("../shared");
+/**
+ * Invariant function to check for no references to module varaibles.
+ * @param path the babel path for the identifier.
+ * @param moduleVars a collection of module variables.
+ * @param classVariables a collection of variables defined within the a getter.
+ * @returns a locatoin object if there are references to a module variable, undefined if not.
+ */
+function checkForNoReferenceToModuleVariables(path, moduleVars, classVariables) {
+    const identifier = path.node;
+    if (moduleVars.includes(identifier.name)) {
+        if (!classVariables.includes(identifier.name)) {
+            if (identifier.loc != null) {
+                return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_EXPRESSION_CONTAINS_MODULE_LEVEL_VARIABLE_REF, shared_1.LLSRange.fromBabelSourceLocation(identifier.loc), [identifier.name]);
+            }
+        }
+    }
+    return undefined;
+}
+exports.checkForNoReferenceToModuleVariables = checkForNoReferenceToModuleVariables;
+/**
+ * Invariant function to check if an identifier references an unsupported import.
+ *
+ * We ignore identifiers in specific usecases for this check predominantly bc of situational awareness:
+ * - Decorator parent: out of scope for this check
+ * - This Expression Parent: this.anything will never be an import ref
+ * - MemberExpression, CallExpression, TaggedTemplateExpression: similar checks done by other invariants so don't have to do them here.
+ *
+ * @param path the babel path object for the current member expression
+ * @param supportedImportRefs a set of supported import references.
+ * @param declaredVariables list of variables declared in the function to manage scoping collisions
+ * @returns undefined if a member expression does NOT reference an unsuppoerted import, PrimingDiagnostic object
+ *          if an unsupported import is reference.
+ */
+function checkIdentifierForNonSupportedNamespaceRefs(path, importReferences, declaredVariables) {
+    const identifier = path.node;
+    if (path.parent.type !== 'Decorator' &&
+        path.parent.type !== 'MemberExpression' &&
+        path.parent.type !== 'CallExpression' &&
+        path.parent.type !== 'TaggedTemplateExpression' &&
+        path.parent.type !== 'ThisExpression' &&
+        importReferences.get(identifier.name) &&
+        !importReferences.get(identifier.name)?.isSupported &&
+        !declaredVariables.includes(identifier.name)) {
+        if (identifier.loc !== null) {
+            return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_REFERENCE_TO_UNSUPPORTED_NAMESPACE_REFERENCE, shared_1.LLSRange.fromBabelSourceLocation(identifier.loc), [identifier.name]);
+        }
+    }
+    return undefined;
+}
+exports.checkIdentifierForNonSupportedNamespaceRefs = checkIdentifierForNonSupportedNamespaceRefs;
+//# sourceMappingURL=identifierInvariantFunctions.js.map

package/build/invariantFunctions/memberExpressionInvariantFunctions.d.ts

@@ -0,0 +1,50 @@
+import { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { PrimingDiagnostic } from '../types';
+import { ClassPropertyInfo, ImportDeclarationInfo, AstContext } from '@komaci/common-shared';
+/**
+ * Invariant function for checking if a member expression references a non decorated member var.
+ * @param path the babel path object for the current member expressoin
+ * @param memberVars a set of approved member variable names.
+ * @returns undefined if the member expression does NOT reference an unsupported member var, PrimingDiagnostic object if an unsuppported
+ *          member variable is referenced
+ */
+export declare function checkForNonSupportedMemberRefs(path: NodePath<t.MemberExpression>, memberVars: ClassPropertyInfo[]): PrimingDiagnostic | undefined;
+/**
+ * Invariant function for checking if a member expression references a non-existent member property variable
+ * @param {NodePath<MemberExpression>} path babel/types path object representing the current member expression
+ * @param {string[]} memberVars an string[] of member variable names
+ * @param {Set<string>} thisAliases a Set of the aliases of `this` used. ex: in `let that = this;`, `that` would be an alias.
+ * @returns {(PrimingDiagnostic | undefined)} undefined if the member expression does NOT reference a non-existent member property variable. Returns a
+ *           PrimingDiagnostic object if a non-existent member property variable is referenced
+ */
+export declare function checkForNonExistentMemberRefs(path: NodePath<t.MemberExpression>, memberVars: ClassPropertyInfo[], thisAliases: Set<string>): PrimingDiagnostic | undefined;
+/**
+ * Invariant function to check if a member expression references an unsupported import.
+ * @param path the babel path object for the current member expression
+ * @param supportedImportRefs a set of supported import references.
+ * @returns undefined if a member expression does NOT reference an unsuppoerted import, PrimingDiagnostic object
+ *          if an unsupported import is reference.
+ */
+export declare function checkMemberExpressionForNonSupportedNamespaceRefs(path: NodePath<t.MemberExpression>, importReferences: Map<string, ImportDeclarationInfo>): PrimingDiagnostic | undefined;
+/**
+ * Validates whether a MemberExpression Node on the AST adheres to a portability invariant (whether it doesn't
+ * contain 'document', 'window' indentifiers within an expression).
+ * @param path NodePath<MemberExpression> containing a MemberExpression to analyze for invariants
+ * @returns PrimingDiagnostic of the MemberExpression if an invariant is detected, or undefined if none was found
+ */
+export declare function checkNoUsageOfDocumentOrWindow(path: NodePath<t.MemberExpression>): PrimingDiagnostic | undefined;
+/**
+ * Invariant function to check weather a member expression contains a call to super.
+ * @param path the babel path object for the current member expressoin
+ * @returns undefined if the member expressoin does NOT contain a reference to a super var or function. Location object if there is a super reference.
+ */
+export declare function checkForNoUseOfSuper(path: NodePath<t.MemberExpression>): PrimingDiagnostic | undefined;
+/**
+ * Function to check if there is an reference to an unsupported global reference.
+ * @param path the member expression path node
+ * @param astContext the ast context that holds meta data about the scr code.
+ * @returns a Priming Diagnostic if there is a global reference undefined if none
+ */
+export declare function checkForUnsupportedGlobalRef(path: NodePath<t.MemberExpression>, astContext: AstContext, declaredGetterVars: string[]): PrimingDiagnostic | undefined;
+//# sourceMappingURL=memberExpressionInvariantFunctions.d.ts.map