@komaci/static-analyzer 240.1.3

package/build/rules.js

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diagnosticMessages = exports.updatePrimingDiagnosticWithFileInfo = exports.getPrimingDiagnostic = void 0;
+const MESSAGE_CODE_PREFIX = 'komaci';
+const SOURCE_PREFIX_OFFLINE_CODE_ANALYZER = 'offline code analyzer';
+var SEVERITY;
+(function (SEVERITY) {
+    SEVERITY["ERROR"] = "error";
+    SEVERITY["WARNING"] = "warning";
+    SEVERITY["INFO"] = "info";
+})(SEVERITY || (SEVERITY = {}));
+const argReplaceRegExp = /\{([0-9]+)\}/g;
+const DIAGNOSTIC_MSG_NOT_FOUND = 'The message for this diagnostic occurence was not found';
+/**
+ * Returns the processed PrimingDiagnostic for a given DianosticMessage message key. If {args} are passed in, they will be substituted into
+ * the message string in the order of the array. If a {filename} is passed in, a {Uri} will be generated that will be included in the DiagnosticMessage
+ * in the format expected by the VSCode language server
+ * @param {DiagnosticMessage} diagnosticMessage the unprocessed diagnostic message (the caller of this method looks up the message with a key)
+ * @param {Range} range the line numbers and column numbers for the starting and endline line and starting and ending columns of the cause of the diagnostic
+ * message in the code, respectively.
+ * @param {Array<string>} args arguments to substitute into the message string
+ * @returns a new, processed instance of PrimingDiagnostic (with arguments substituted in, and Uri set) which is compatible with the VSCode language server
+ */
+function getPrimingDiagnostic(diagnosticMessage, range, args) {
+    const primingDiagnostic = {
+        range: range,
+        ...diagnosticMessage,
+    };
+    if (!diagnosticMessage) {
+        primingDiagnostic.message = DIAGNOSTIC_MSG_NOT_FOUND;
+    }
+    // does argument substitution for message, if args exist
+    primingDiagnostic.message = primingDiagnostic.message.replace(argReplaceRegExp, (_, index) => {
+        return args && args[index] ? args[index] : '';
+    });
+    return primingDiagnostic;
+}
+exports.getPrimingDiagnostic = getPrimingDiagnostic;
+/**
+ * This method augments the PrimingDiagnostic with filename information. It augments the
+ * object by reference and does not return a modified object.
+ * @param {PrimingDiagnostic} primingDiagnostic The PrimingDiagnostic that needs to be augmented with filename informations
+ * @param {string | undefined} filename The name of the file that the PrimingDiagnostic is for
+ * @returns {PrimingDiagnostic} a PrimingDiagnostic (this is optional to use)
+ */
+function updatePrimingDiagnosticWithFileInfo(primingDiagnostic, filename) {
+    if (filename && filename.length > 0) {
+        const uri = {
+            scheme: 'file',
+            path: filename,
+            fragment: '',
+            query: '',
+            authority: '',
+        };
+        // convert the komaci field to one that supports file names, but only if it exists
+        if (primingDiagnostic.code) {
+            primingDiagnostic.code = {
+                target: uri,
+                value: primingDiagnostic.code,
+            };
+        }
+    }
+    return primingDiagnostic;
+}
+exports.updatePrimingDiagnosticWithFileInfo = updatePrimingDiagnosticWithFileInfo;
+exports.diagnosticMessages = {
+    NO_UNRESOLVED_PARENT_CLASS_REFERENCE: {
+        code: `${MESSAGE_CODE_PREFIX}1001`,
+        severity: SEVERITY.ERROR,
+        message: 'This class refers to an unresolved parent class',
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_MULTIPLE_TEMPLATE_FILES: {
+        code: `${MESSAGE_CODE_PREFIX}1002`,
+        severity: SEVERITY.WARNING,
+        message: 'This analyzer does not support LWCs which render multiple template files',
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_PRIVATE_WIRE_CONFIG_PROPERTY: {
+        code: `${MESSAGE_CODE_PREFIX}1003`,
+        severity: SEVERITY.ERROR,
+        message: "This wire configuration uses a property '{0}' that is private",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_UNDEFINED_WIRE_CONFIG_PROPERTY: {
+        code: `${MESSAGE_CODE_PREFIX}1004`,
+        severity: SEVERITY.WARNING,
+        message: "This wire configuration uses a property '{0}' which is undefined",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_CONDITIONAL_USING_PROPERTY_FROM_UNRESOLVABLE_WIRE: {
+        code: `${MESSAGE_CODE_PREFIX}1005`,
+        severity: SEVERITY.ERROR,
+        message: "This conditional acts upon an unanalyzable property '{0}' that is wired by a unresolvable wire",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_WIRE_CONFIGURATION_PROPERTY_USING_OUTPUT_OF_NON_PRIMEABLE_WIRE: {
+        code: `${MESSAGE_CODE_PREFIX}1006`,
+        severity: SEVERITY.ERROR,
+        message: "The wire configuration uses a property '{0}' that is the output of a non-primeable wire, making this wire non-primeable",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_WIRE_ADAPTER_OF_RESOURCE_CANNOT_BE_PRIMED: {
+        code: `${MESSAGE_CODE_PREFIX}1007`,
+        severity: SEVERITY.ERROR,
+        message: "The wire adapter '{0}' of resource '{1}' cannot be primed",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_MISSING_RESOURCE_CANNOT_PRIME_WIRE_ADAPTER: {
+        code: `${MESSAGE_CODE_PREFIX}1008`,
+        severity: SEVERITY.ERROR,
+        message: 'The wire adapter cannot be primed because it refers to a missing resource',
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_WIRE_CONFIG_PROPERTY_USES_GETTER_FUNCTION_RETURNING_NON_LITERAL: {
+        code: `${MESSAGE_CODE_PREFIX}1009`,
+        severity: SEVERITY.ERROR,
+        message: "This wire configuration uses a property from a getter function named '{0}' that returns a non-literal",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_WIRE_CONFIG_PROPERTY_USES_GETTER_FUNCTION_RETURNING_INACCESSIBLE_IMPORT: {
+        code: `${MESSAGE_CODE_PREFIX}1010`,
+        severity: SEVERITY.ERROR,
+        message: "This wire configuration uses a property from a getter function named '{0}' that returns an inaccessible import",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_CLASS_REFERS_TO_PARENT_CLASS_FROM_UNSUPPORTED_NAMESPACE: {
+        code: `${MESSAGE_CODE_PREFIX}1011`,
+        severity: SEVERITY.ERROR,
+        message: 'This class refers to a parent class from an unsupported namespace',
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_WIRE_CONFIG_PROPERTY_USES_IMPORTED_ARTIFACT_FROM_UNSUPPORTED_NAMESPACE: {
+        code: `${MESSAGE_CODE_PREFIX}1012`,
+        severity: SEVERITY.ERROR,
+        message: "This wire configuration uses an imported artifact '{0}' from unsupported namespace '{1}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_WIRE_CONFIG_REFERENCES_NON_LOCAL_PROPERTY_REACTIVE_VALUE: {
+        code: `${MESSAGE_CODE_PREFIX}1013`,
+        severity: SEVERITY.WARNING,
+        message: "This wire configuration references a reactive value '{0}' that is not a local property",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_ITERATE_ON_UNANALYZABLE_PROPERTY_FROM_UNRESOLVABLE_WIRE: {
+        code: `${MESSAGE_CODE_PREFIX}1014`,
+        severity: SEVERITY.ERROR,
+        message: "This iterator iterates upon an unanalyzable property '{0}' that is wired by a unresolvable wire",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_ITERATE_ON_UNANALYZABLE_PROPERTY_FROM_NON_PUBLIC_PROPERTY: {
+        code: `${MESSAGE_CODE_PREFIX}1015`,
+        severity: SEVERITY.ERROR,
+        message: "This iterator iterates upon an unanalyzable property '{0}' that is not a public property",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_CONDITIONAL_ON_UNANALYZABLE_GETTER_PROPERTY: {
+        code: `${MESSAGE_CODE_PREFIX}1016`,
+        severity: SEVERITY.ERROR,
+        message: "This conditional acts upon an unanalyzable getter property '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_CONDITIONAL_ON_UNANALYZABLE_NON_PUBLIC_GETTER_PROPERTY: {
+        code: `${MESSAGE_CODE_PREFIX}1017`,
+        severity: SEVERITY.ERROR,
+        message: "This conditional acts upon an unanalyzable getter property '{0}' that is not a public property",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_WIRE_CONFIG_PROPERTY_CIRCULAR_WIRE_DEPENDENCY: {
+        code: `${MESSAGE_CODE_PREFIX}1018`,
+        severity: SEVERITY.ERROR,
+        message: "The wire configuration input property '{0}' of this wire is part of a chain of circular wire " +
+            'dependencies, and will result an infinite loop during runtime. Please refactor ' +
+            "code to remove the circular dependency. Dependency chain: '{1}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_ITERATE_ON_UNANALYZABLE_GETTER_PROPERTY: {
+        code: `${MESSAGE_CODE_PREFIX}1019`,
+        severity: SEVERITY.ERROR,
+        message: "This iterator iterates upon an unanalyzable getter property '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_CONDITIONAL_USING_UNANALYZABLE_NON_PUBLIC_PROPERTY: {
+        code: `${MESSAGE_CODE_PREFIX}1020`,
+        severity: SEVERITY.ERROR,
+        message: "This conditional acts upon an unanalyzable property '{0}' that is not a public property",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_ITERATE_ON_UNANALYZABLE_PROPERTY: {
+        code: `${MESSAGE_CODE_PREFIX}1021`,
+        severity: SEVERITY.ERROR,
+        message: "This iterator iterates upon an unanalyzable property '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_ASSIGNMENT_EXPRESSION_ASSIGNS_VALUE_TO_MEMBER_VARIABLE: {
+        code: `${MESSAGE_CODE_PREFIX}1022`,
+        severity: SEVERITY.ERROR,
+        message: "Assignment expression cannot assign a value to member variable '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_ASSIGNMENT_EXPRESSION_FOR_EXTERNAL_COMPONENTS: {
+        code: `${MESSAGE_CODE_PREFIX}1023`,
+        severity: SEVERITY.ERROR,
+        message: 'Assignment Expressions are not supported for external components',
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_TAGGED_TEMPLATE_EXPRESSION_CONTAINS_UNSUPPORTED_NAMESPACE: {
+        code: `${MESSAGE_CODE_PREFIX}1024`,
+        severity: SEVERITY.ERROR,
+        message: "Tagged Template Expression contains a reference to an unsupported namespace '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_GETTER_CONTAINS_MORE_THAN_RETURN_STATEMENT: {
+        code: `${MESSAGE_CODE_PREFIX}1025`,
+        severity: SEVERITY.ERROR,
+        message: 'Supported getters can only contain a return statement',
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_EXPRESSION_CONTAINS_MODULE_LEVEL_VARIABLE_REF: {
+        code: `${MESSAGE_CODE_PREFIX}1026`,
+        severity: SEVERITY.ERROR,
+        message: "Expression contains a reference to a variable at the module level: '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_CALL_EXPRESSION_REFERENCES_UNSUPPORTED_NAMESPACE: {
+        code: `${MESSAGE_CODE_PREFIX}1027`,
+        severity: SEVERITY.ERROR,
+        message: "Call expression contains reference to an unsupported namespace '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_EVAL_USAGE: {
+        code: `${MESSAGE_CODE_PREFIX}1028`,
+        severity: SEVERITY.ERROR,
+        message: "Call expression contains non-portable identifier '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_REFERENCE_TO_CLASS_FUNCTIONS: {
+        code: `${MESSAGE_CODE_PREFIX}1029`,
+        severity: SEVERITY.ERROR,
+        message: "Call expression contains reference to function defined on the class '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_REFERENCE_TO_MODULE_FUNCTIONS: {
+        code: `${MESSAGE_CODE_PREFIX}1030`,
+        severity: SEVERITY.ERROR,
+        message: "Call expression contains reference to function defined on the module '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_FUNCTIONS_DECLARED_WITHIN_GETTER_METHOD: {
+        code: `${MESSAGE_CODE_PREFIX}1031`,
+        severity: SEVERITY.ERROR,
+        message: 'Functions may not be declared within a getter method',
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_UNSUPPORTED_MEMBER_VARIABLE_IN_MEMBER_EXPRESSION: {
+        code: `${MESSAGE_CODE_PREFIX}1032`,
+        severity: SEVERITY.ERROR,
+        message: "Member expression contains reference to unsupported member variable '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_MEMBER_EXPRESSION_REFERENCE_TO_NON_EXISTENT_MEMBER_VARIABLE: {
+        code: `${MESSAGE_CODE_PREFIX}1033`,
+        severity: SEVERITY.ERROR,
+        message: "Member expression contains reference to non-existent member variable '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_MEMBER_EXPRESSION_REFERENCE_TO_UNSUPPORTED_NAMESPACE_REFERENCE: {
+        code: `${MESSAGE_CODE_PREFIX}1034`,
+        severity: SEVERITY.ERROR,
+        message: "Member expression contains reference to unsupported namespace reference: '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_MEMBER_EXPRESSION_CONTAINS_NON_PORTABLE_IDENTIFIER: {
+        code: `${MESSAGE_CODE_PREFIX}1035`,
+        severity: SEVERITY.ERROR,
+        message: "Member expression contains non-portable identifier '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_MEMBER_EXPRESSION_REFERENCE_TO_SUPER_CLASS: {
+        code: `${MESSAGE_CODE_PREFIX}1036`,
+        severity: SEVERITY.ERROR,
+        message: "Member expression contains reference to super class: '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_MEMBER_EXPRESSION_REFERENCE_TO_UNSUPPORTED_GLOBAL: {
+        code: `${MESSAGE_CODE_PREFIX}1037`,
+        severity: SEVERITY.ERROR,
+        message: "Member expression contains reference to unsupported global: '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_REFERENCE_TO_UNSUPPORTED_NAMESPACE_REFERENCE: {
+        code: `${MESSAGE_CODE_PREFIX}1038`,
+        severity: SEVERITY.ERROR,
+        message: "Reference to import '{0}' from an unsupported namespace is not allowed",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_IMAGE_REFERENCE_UNANALYZABLE_SOURCE_PROPERTY: {
+        code: `${MESSAGE_CODE_PREFIX}1039`,
+        severity: SEVERITY.ERROR,
+        message: "Image tag references in its source attribute the unanalyzable property '{0}'",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_IMAGE_REFERENCE_MISSING_SOURCE_PROPERTY: {
+        code: `${MESSAGE_CODE_PREFIX}1040`,
+        severity: SEVERITY.ERROR,
+        message: "Image tag references in its source attribute a property '{0}' which does not exist in the corresponding script file",
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+};
+//# sourceMappingURL=rules.js.map

package/build/shared.d.ts

@@ -0,0 +1,52 @@
+import { ClassPropertyContexts } from '@komaci/common-shared';
+import { GetPrimingAdapter } from './types';
+import { SourceLocation } from '@babel/types';
+import { PrimingDiagnostic, Range } from '.';
+import { Composition, Image, SourceLocation as KomaciSourceLocation } from '@komaci/types';
+export declare const WIRE_FUNCTION = "WireFunction";
+export declare const ERROR_PREFIX = "[komaci static-analyzer] ";
+/**
+ * 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;
+/**
+ * Determine whether the resource name is in a supported namespace
+ * @param resourceName the resource name of the Import, as a string
+ * @returns boolean true if the resource name is in a supported namespace
+ */
+export declare function isSupportedNamespace(resourceName: string | undefined): boolean;
+export declare const getPrimingAdapter: GetPrimingAdapter;
+export declare const LLSRange: {
+    /**
+     * Converts an lwc-metadata SourceLocation (1-indexed for both line and column) into a Lightning Language
+     * Server-compatible Range object.
+     * @param {Location} location the SourceLocation, as represented by lwc-metadata, with komaci SourceLocation type
+     * @returns {Range} the komaci, Lightning Language Server-compatible Range object
+     */
+    fromLWCSourceLocation(location: KomaciSourceLocation | undefined): Range;
+    /**
+     * Converts a BabelJS SourceLocation (1-indexed for line, 0-indexed for column) into a Lightning Language
+     * Server-compatible Range object.
+     * @param {Location} location the SourceLocation, as represented by lwc-metadata, with komaci SourceLocation type
+     * @returns {Range} the komaci, Lightning Language Server-compatible Range object
+     */
+    fromBabelSourceLocation({ start, end }: SourceLocation): Range;
+};
+/**
+ * Function to analyze getter functions and collect any Priming Diagnostic info for invalid gettters.
+ * @param srcCode the source code to analyze.
+ * @param namespace the namespace of src file.
+ */
+export declare function analyzeSrcForInvalidGetterFunctions(srcCode: string, namespace: string, properties: ClassPropertyContexts): PrimingDiagnostic[];
+/**
+ * Type guard for the komaci Image type
+ * @param {Composition} composition the komaci Composition object
+ * @returns {boolean} true if the Composition is more specifically an Image, false if it is not an Image
+ */
+export declare function isImageComposition(composition: Composition): composition is Image;
+//# sourceMappingURL=shared.d.ts.map

package/build/shared.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImageComposition = exports.analyzeSrcForInvalidGetterFunctions = exports.LLSRange = exports.getPrimingAdapter = exports.isSupportedNamespace = exports.isSupportedWireAdapter = exports.ERROR_PREFIX = exports.WIRE_FUNCTION = void 0;
+const adaptersMapping_1 = require("./adaptersMapping");
+const allowlistAdapters_1 = require("./allowlistAdapters");
+const common_shared_1 = require("@komaci/common-shared");
+const validateGetter_1 = require("./validateGetter");
+// TODO: eventually refactor list consts into their own file
+exports.WIRE_FUNCTION = 'WireFunction';
+exports.ERROR_PREFIX = '[komaci static-analyzer] ';
+const emptyRange = {
+    start: { line: 0, character: 0 },
+    end: { line: 0, character: 0 },
+};
+/**
+ * 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;
+/**
+ * Determine whether the resource name is in a supported namespace
+ * @param resourceName the resource name of the Import, as a string
+ * @returns boolean true if the resource name is in a supported namespace
+ */
+function isSupportedNamespace(resourceName) {
+    // check for relative, null, or empty namespaces (which are not allowed)
+    // Ex: undefined, '', './app_const1', './parent.html'
+    if (!resourceName || resourceName === '' || resourceName.startsWith('./')) {
+        return false;
+    }
+    // imports where parent class is for a relative import.
+    // Ex: import { Foo } from './foo';
+    if (resourceName.startsWith('@salesforce/komaci/.')) {
+        return false;
+    }
+    return ((0, common_shared_1.isNamespaceInternal)((0, common_shared_1.getNamespaceFromImport)(resourceName)) &&
+        (0, common_shared_1.isLibraryValid)(resourceName));
+}
+exports.isSupportedNamespace = isSupportedNamespace;
+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;
+/* Related utilty functions to convert Locations of various types into a Range format and indexing scheme supported by
+   the Lightning Language Server
+   (0-index based for lines and columns, and a specific format where `column` is called `character`) */
+exports.LLSRange = {
+    /**
+     * Converts an lwc-metadata SourceLocation (1-indexed for both line and column) into a Lightning Language
+     * Server-compatible Range object.
+     * @param {Location} location the SourceLocation, as represented by lwc-metadata, with komaci SourceLocation type
+     * @returns {Range} the komaci, Lightning Language Server-compatible Range object
+     */
+    fromLWCSourceLocation(location) {
+        let range;
+        if (location === undefined) {
+            range = emptyRange;
+        }
+        else {
+            // switch from lwc-metadata 1-index based range to 0-index based range
+            // as required by lightning language server
+            const startPos = {
+                line: location.startLine - 1,
+                character: location.startColumn - 1,
+            };
+            const endPos = {
+                line: location.endLine - 1,
+                character: location.endColumn - 1,
+            };
+            range = {
+                start: startPos,
+                end: endPos,
+            };
+        }
+        return range;
+    },
+    /**
+     * Converts a BabelJS SourceLocation (1-indexed for line, 0-indexed for column) into a Lightning Language
+     * Server-compatible Range object.
+     * @param {Location} location the SourceLocation, as represented by lwc-metadata, with komaci SourceLocation type
+     * @returns {Range} the komaci, Lightning Language Server-compatible Range object
+     */
+    fromBabelSourceLocation({ start, end }) {
+        return {
+            start: {
+                line: start.line - 1,
+                character: start.column,
+            },
+            end: {
+                line: end.line - 1,
+                character: end.column,
+            },
+        };
+    },
+};
+/**
+ * Function to analyze getter functions and collect any Priming Diagnostic info for invalid gettters.
+ * @param srcCode the source code to analyze.
+ * @param namespace the namespace of src file.
+ */
+function analyzeSrcForInvalidGetterFunctions(srcCode, namespace, properties) {
+    const rootAst = (0, common_shared_1.generateAstFromSrcCode)(srcCode);
+    const moduleContext = {
+        astContext: (0, common_shared_1.getAstContextObject)(rootAst),
+        isExternal: (0, common_shared_1.isExternalModule)(namespace),
+    };
+    const diagnostics = [];
+    const { getters } = (0, common_shared_1.getPropertyMetadataFromAst)(rootAst);
+    const identifiers = new Set();
+    const checkForPropertyReferences = {
+        // visitor for each type
+        MemberExpression(path) {
+            (0, common_shared_1.getMemberVarsFromGetter)(path, identifiers);
+        },
+    };
+    if (getters.length > 0) {
+        getters
+            .map((getter) => {
+            identifiers.clear();
+            getter.traverse(checkForPropertyReferences);
+            const name = (0, common_shared_1.getClassMethodName)(getter);
+            (0, common_shared_1.updatePropertyUsage)(name, Array.from(identifiers), properties, common_shared_1.PropertyTypes.GETTER);
+            return getter;
+        })
+            .forEach((func) => {
+            const res = (0, validateGetter_1.validateGetter)(func, moduleContext, true);
+            const getterDiagnostics = res;
+            diagnostics.push(...getterDiagnostics);
+        });
+    }
+    return diagnostics;
+}
+exports.analyzeSrcForInvalidGetterFunctions = analyzeSrcForInvalidGetterFunctions;
+/**
+ * Type guard for the komaci Image type
+ * @param {Composition} composition the komaci Composition object
+ * @returns {boolean} true if the Composition is more specifically an Image, false if it is not an Image
+ */
+function isImageComposition(composition) {
+    return composition.type === 'Image';
+}
+exports.isImageComposition = isImageComposition;
+//# sourceMappingURL=shared.js.map

package/build/staticAnalyzer.d.ts

@@ -0,0 +1,100 @@
+import { AnalyzerInput, PrimingDiagnostic, Range, Position, WireInfo } from './types';
+export declare class StaticAnalyzer {
+    startPos: Position;
+    endPos: Position;
+    emptyRange: Range;
+    orderedWireInfos: WireInfo[];
+    wireInfoMap: Map<number, WireInfo>;
+    fileNamesMap: Map<string, string>;
+    /**
+     * Given a bundle of files of different types (html, js), this method will perform static analysis of the input source files,
+     * and will output the result of the analysis as an array of PrimingDiagnostic objects that are compliant with the lightning language server specifications.
+     * @param input AnalyzerInput object containing the source files, their types, and namespace information required for analysis.
+     * @returns array of PrimingDiagnostic, with each element containing the analysis message and location information for IDE syntax underlining.
+     */
+    analyzeBundle(input: AnalyzerInput): PrimingDiagnostic[];
+    /**
+     * Given a script (JS) file, this method will perform static analysis of the input source JS files,
+     * and will output the result of the analysis as an array of PrimingDiagnostic objects that are compliant with the lightning language server specifications.
+     * @param input AnalyzerInput object containing the source JS files, namespace and other information required for analysis.
+     * @returns array of PrimingDiagnostic, with each element containing the analysis message and location information for IDE syntax underlining.
+     */
+    analyzeScript(input: AnalyzerInput): PrimingDiagnostic[];
+    private processKomaciScriptDoc;
+    /**
+     * Given bundle komaciDocs, produce diagnostics for conditionals and iterators which are unanalyzable
+     * @param templateKomaciDoc KomaciDoc which provides composition information
+     * @param scriptKomaciDoc KomaciDoc which provides relevant adg information
+     * @returns array of PrimingDiagnostic, with each element containing the analysis message and location information for IDE syntax underlining.
+     */
+    private processKomaciTemplateDoc;
+    private findWireConfigsThatUsePrivateProperty;
+    /**
+     * Traverses direct dependencies of the input wire (represented by a WireInfo) to see if any
+     * are non-analyzable. If any are, the input wire is also marked as non-analyzable, and a PrimingDiagnostic
+     * is generated for each dependency that is non-analyzable.
+     * @param wireInfo the current WireInfo to evaluate
+     * @param orderedWireInfos an array of dependency-sorted WireInfo against which to check the
+     *          state of dependencies of wireInfo
+     * @returns array of PrimingDiagnostic containing a diagnostic for all non-analyzable wires found.
+     */
+    private findPropagatedUnresolvedWireAdaptersFromConfigProp;
+    private findUnresolvableWireAdaptersFromImports;
+    private findWireConfigGetterReturningNonLiteral;
+    private findWireConfigForGetterReturningInaccessibleImports;
+    private findUnresolvedParentClass;
+    private findParentClassFromUnsupportedNS;
+    private findWiresWithReactivePropNameFromUnsupportedNS;
+    /**
+     * identify unsupported namespaces usage nested within wireConfig array property
+     */
+    private findNestedUnsupportedNSArray;
+    /**
+     * identify unsupported namespaces usage nested within wireConfig object property
+     */
+    private findNestedUnsupportedNSObject;
+    private findWireConfigReferenceNonExistProperty;
+    /**
+     * Produce diagnostics for iterators which iterate on unresolvable inputs, such as private properties
+     * or wired properties which associated to unresolvable wires
+     */
+    private findUnresolvableIterator;
+    /**
+     * Produce diagnostics for conditionals which act upon unresolvable inputs, such as private properties
+     * or wired properties which associated to unresolvable wires
+     */
+    private findUnresolvableConditional;
+    /**
+     * Produces diagnostic for images which refer to unresolvable `src` attributes within the `<img>` tag.
+     * Note that Images are a type of Composition
+     *
+     * @param {Composition} image the composition containing the Image
+     * @param {Adg[]} adgs an array of ADGs
+     * @returns {PrimingDiagnostic} a PrimingDiagnostic if an image with unresolvable `src` attribute is found. void otherwise
+     */
+    private findUnresolvableImage;
+    /**
+     * Convert array of Compositions into flattened array of Compositions,
+     * visiting top-level and nested children compositions
+     */
+    private compositionsToArray;
+    /**
+     * find Import name information (resourceName, importName) given komaciDoc imports and reference
+     */
+    private findImport;
+    private getMetadata;
+    private findWireConfigReferenceCircularDependency;
+    /**
+     * Given an input array of FunctionType function nodes, this method creates an array of WireInfo that is
+     * ordered in such a way that independent WireFunction nodes are placed towards the beginning of the array, and the
+     * most dependent ones are placed towards the end of the array, so that iterating the array from beginning to end
+     * while evaluating wire conditions without running into unencountered dependencies is actually possible
+     * @param adg Adg, containing needed properties for this method
+     * @param funcs Array of FunctionType, which correspond to WireInfos that this method creates
+     * @returns and array of WireInfo, which contain references to FunctionType nodes for Wires, and other important state
+     */
+    private reorderFunctionsByWireDependency;
+    private dependsOn;
+    private findWireInfo;
+}
+//# sourceMappingURL=staticAnalyzer.d.ts.map