@komaci/static-analyzer 240.1.3

package/build/staticAnalyzer.js

@@ -0,0 +1,822 @@
+"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.StaticAnalyzer = void 0;
+const collector = __importStar(require("@lwc-platform/lwc-metadata-next"));
+const rules_1 = require("./rules");
+const common_shared_1 = require("@komaci/common-shared");
+const shared_1 = require("./shared");
+const WireGraph_1 = require("./WireGraph");
+class StaticAnalyzer {
+    constructor() {
+        // TODO: Remove this sample Range when it is no longer needed as a placeholder
+        this.startPos = { line: 0, character: 0 };
+        this.endPos = { line: 0, character: 0 };
+        this.emptyRange = {
+            start: this.startPos,
+            end: this.endPos,
+        };
+        this.orderedWireInfos = [];
+        this.wireInfoMap = new Map();
+        this.fileNamesMap = new Map();
+    }
+    /**
+     * 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) {
+        const diagnostics = [];
+        if (input.type === 'bundle') {
+            // generate komaciDoc from source file from collector in lwc-metadata-next package
+            const metadataObj = this.getMetadata(input);
+            if (metadataObj) {
+                let templateKomaciDoc;
+                let scriptKomaciDoc;
+                let sourceFileName;
+                let templateLimitReached = false;
+                for (const file of metadataObj.files) {
+                    if (file.komaciDoc) {
+                        if (file.fileName.split('.')[0] != input.name) {
+                            continue; // ignore files whose name do not match module name
+                        }
+                        if (file.fileType === 'js') {
+                            const fileName = file.fileName;
+                            this.fileNamesMap.set('js', fileName);
+                            sourceFileName = fileName;
+                            scriptKomaciDoc = file.komaciDoc;
+                        }
+                        else if (file.fileType === 'html') {
+                            if (templateLimitReached === true) {
+                                // a template file has been processed already
+                                diagnostics.push((0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_MULTIPLE_TEMPLATE_FILES, this.emptyRange, []), this.fileNamesMap.get('html')));
+                            }
+                            else {
+                                templateKomaciDoc = file.komaciDoc;
+                                templateLimitReached = true;
+                                this.fileNamesMap.set('html', file.fileName);
+                            }
+                        }
+                    }
+                }
+                if (sourceFileName && scriptKomaciDoc) {
+                    const properties = (0, common_shared_1.collectPropertyMetadataFromScriptDoc)(scriptKomaciDoc);
+                    if (templateKomaciDoc) {
+                        (0, common_shared_1.updatePropertyMetadataFromTemplateDoc)(templateKomaciDoc, properties);
+                    }
+                    const srcCode = input.files[sourceFileName];
+                    const getterFunctionDiagnostics = (0, shared_1.analyzeSrcForInvalidGetterFunctions)(srcCode, input.namespace, properties);
+                    if (getterFunctionDiagnostics.length > 0) {
+                        getterFunctionDiagnostics.map((diagnostic) => (0, rules_1.updatePrimingDiagnosticWithFileInfo)(diagnostic, sourceFileName));
+                        diagnostics.push(...getterFunctionDiagnostics);
+                    }
+                }
+                this.processKomaciScriptDoc(scriptKomaciDoc, diagnostics);
+                this.processKomaciTemplateDoc(templateKomaciDoc, scriptKomaciDoc, diagnostics);
+            }
+            return diagnostics;
+        }
+        else {
+            throw new Error(shared_1.ERROR_PREFIX +
+                'this method was invoked with unexpected input type: ' +
+                input.type);
+        }
+    }
+    /**
+     * 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) {
+        const diagnostics = [];
+        if (input.type === 'file') {
+            // generate komaciDoc from source file from collector in lwc-metadata-next package
+            const metadataObj = this.getMetadata(input);
+            // since this is analyze script, this array only has one element for analyzeScript case.
+            const komaciDoc = metadataObj?.files[0].komaciDoc;
+            // get the file name and store for VSCode analysis display purposes
+            const fileName = metadataObj?.files[0].fileName;
+            this.fileNamesMap.set('js', fileName);
+            if (komaciDoc) {
+                const properties = (0, common_shared_1.collectPropertyMetadataFromScriptDoc)(komaciDoc);
+                const srcCode = input.sourceFile;
+                const getterFunctionDiagnostics = (0, shared_1.analyzeSrcForInvalidGetterFunctions)(srcCode, input.namespace, properties);
+                if (getterFunctionDiagnostics.length > 0) {
+                    getterFunctionDiagnostics.map((diagnostic) => (0, rules_1.updatePrimingDiagnosticWithFileInfo)(diagnostic, this.fileNamesMap.get('js')));
+                    diagnostics.push(...getterFunctionDiagnostics);
+                }
+            }
+            return this.processKomaciScriptDoc(komaciDoc, diagnostics);
+        }
+        else {
+            throw new Error(shared_1.ERROR_PREFIX +
+                'this method was invoked with unexpected input type: ' +
+                input.type);
+        }
+    }
+    processKomaciScriptDoc(komaciDoc, diagnostics) {
+        if (komaciDoc && komaciDoc.adgs) {
+            for (const adg of komaciDoc.adgs) {
+                if (adg.functions) {
+                    this.orderedWireInfos = this.reorderFunctionsByWireDependency(adg, adg.functions);
+                    // loop on ordered WireInfos, fetch the FunctionType (function node) from there.
+                    for (const wireInfo of this.orderedWireInfos) {
+                        const func = wireInfo.wireFunction;
+                        let problem;
+                        // unit-tested by: artifact-script-files/wireImportUnresolved, artifact-script-files/invalidWireAdapter
+                        problem = this.findUnresolvableWireAdaptersFromImports(func, komaciDoc.imports);
+                        if (problem) {
+                            wireInfo.isNonAnalyzable = true;
+                            diagnostics.push(problem);
+                        }
+                        // unit-tested by: artifact-script-files/privatePropWireConfig
+                        // using spread operator (...) to append more than one item (potentially) at the same time
+                        problem = this.findWireConfigsThatUsePrivateProperty(adg, func);
+                        if (problem && problem.length > 0) {
+                            wireInfo.isNonAnalyzable = true;
+                            diagnostics.push(...problem);
+                        }
+                        // unit-tested by: artifact-script-files/wireCfgGetterReturnsNonLiteral
+                        problem = this.findWireConfigGetterReturningNonLiteral(adg, func);
+                        if (problem && problem.length > 0) {
+                            wireInfo.isNonAnalyzable = true;
+                            diagnostics.push(...problem);
+                        }
+                        // unit-tested by: artifact-script-files/wireCfgGetterReturnsInaccessibleImports
+                        problem =
+                            this.findWireConfigForGetterReturningInaccessibleImports(adg, func, komaciDoc.imports);
+                        if (problem && problem.length > 0) {
+                            wireInfo.isNonAnalyzable = true;
+                            diagnostics.push(...problem);
+                        }
+                        // unit-tested by: artifact-script-files/wireImportUnsupportedNamespace
+                        problem = this.findWiresWithReactivePropNameFromUnsupportedNS(func, komaciDoc.imports);
+                        if (problem && problem.length > 0) {
+                            wireInfo.isNonAnalyzable = true;
+                            diagnostics.push(...problem);
+                        }
+                        // unit-tested by: artifact-script-files/nonExistPropWireConfig
+                        problem = this.findWireConfigReferenceNonExistProperty(adg, func);
+                        if (problem && problem.length > 0) {
+                            wireInfo.isNonAnalyzable = true;
+                            diagnostics.push(...problem);
+                        }
+                        // unit-tested by: artifact-script-files/
+                        problem = this.findPropagatedUnresolvedWireAdaptersFromConfigProp(wireInfo, this.orderedWireInfos);
+                        if (problem && problem.length > 0) {
+                            wireInfo.isNonAnalyzable = true;
+                            diagnostics.push(...problem);
+                        }
+                    }
+                }
+                // unit-tested by: artifact-script-files/unresolvedParentClass
+                let diagnostic = this.findUnresolvedParentClass(adg);
+                if (diagnostic) {
+                    diagnostics.push(diagnostic);
+                }
+                // unit-tested by: artifact-script-files/unresolvedRelativeImport
+                const diagnosticPc = this.findParentClassFromUnsupportedNS(adg, komaciDoc.imports);
+                if (diagnosticPc) {
+                    diagnostics.push(diagnosticPc);
+                }
+                // unit-tested by: artifact-script-files/wireCircular(RefSimple|RefMedium|RefComplex)
+                diagnostic = this.findWireConfigReferenceCircularDependency();
+                if (diagnostic) {
+                    diagnostics.push(diagnostic);
+                }
+            }
+        }
+        return diagnostics;
+    }
+    /**
+     * 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.
+     */
+    processKomaciTemplateDoc(templateKomaciDoc, scriptKomaciDoc, diagnostics) {
+        if (templateKomaciDoc?.compositions &&
+            scriptKomaciDoc?.adgs &&
+            scriptKomaciDoc?.exports) {
+            const adgs = [];
+            const defaultExport = scriptKomaciDoc.exports['default'];
+            if (defaultExport && defaultExport.type === 'AdgReference') {
+                const defaultAdg = scriptKomaciDoc.adgs[defaultExport.value];
+                adgs.push(defaultAdg);
+                let parentClass = defaultAdg.parentClass;
+                while (parentClass?.type === 'AdgReference') {
+                    const parentAdg = scriptKomaciDoc.adgs[parentClass.value];
+                    adgs.push(parentAdg);
+                    parentClass = parentAdg.parentClass;
+                }
+            }
+            const compositionArray = this.compositionsToArray(templateKomaciDoc.compositions);
+            for (const composition of compositionArray) {
+                // tested by: artifact-combined-files/unresolvableIterator
+                let diagnostic = this.findUnresolvableIterator(composition, adgs);
+                if (diagnostic) {
+                    diagnostics.push(diagnostic);
+                }
+                // tested by: artifact-combined-files/unresolvableConditional
+                diagnostic = this.findUnresolvableConditional(composition, adgs);
+                if (diagnostic) {
+                    diagnostics.push(diagnostic);
+                }
+                // test by: artifact-combined-files/unresolvedImageBinding
+                diagnostic = this.findUnresolvableImage(composition, adgs);
+                if (diagnostic) {
+                    diagnostics.push(diagnostic);
+                }
+            }
+        }
+        return diagnostics;
+    }
+    findWireConfigsThatUsePrivateProperty(adg, func) {
+        const diagnostics = [];
+        if (adg.properties) {
+            if (func.type === shared_1.WIRE_FUNCTION && func.input && func.location) {
+                for (const inputProp of func.input) {
+                    if (inputProp.type === 'ObjectValue') {
+                        // inputProp.value = { recordId: {type: "", value: ""}}
+                        for (const propName in inputProp.value) {
+                            const prop = inputProp.value[propName];
+                            // Looking for a PropertyReference type here. That's the only one we are interested in here
+                            if (prop.type === 'PropertyReference') {
+                                // We attempt a split in case we have a nested property name (ex: record.data.name)
+                                // We only care about the first part (first element)
+                                const adgPropName = prop.value.split('/')[0];
+                                if (adg.properties[adgPropName] &&
+                                    !adg.properties[adgPropName].isPublic &&
+                                    !adg.properties[adgPropName].input) {
+                                    const parsedProps = adgPropName.split(',');
+                                    const range = shared_1.LLSRange.fromLWCSourceLocation(func.location);
+                                    const srcFileName = this.fileNamesMap.get('js');
+                                    if (parsedProps.length < 2) {
+                                        diagnostics.push((0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_PRIVATE_WIRE_CONFIG_PROPERTY, range, [parsedProps[0]]), srcFileName));
+                                    }
+                                    else {
+                                        diagnostics.push((0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_UNDEFINED_WIRE_CONFIG_PROPERTY, range, [parsedProps[0]]), srcFileName));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return diagnostics;
+    }
+    /**
+     * 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.
+     */
+    findPropagatedUnresolvedWireAdaptersFromConfigProp(wireInfo, orderedWireInfos) {
+        const diagnostics = [];
+        const funcObj = wireInfo.wireFunction;
+        for (const depWireInfo of wireInfo.dependentWires) {
+            const depFunc = depWireInfo.wireFunction;
+            const updatedWireInfo = orderedWireInfos.find((wire) => wire.funcIndex === depWireInfo.funcIndex);
+            if (updatedWireInfo?.isNonAnalyzable &&
+                depFunc &&
+                depFunc.type === 'WireFunction' &&
+                funcObj?.location) {
+                diagnostics.push((0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_WIRE_CONFIGURATION_PROPERTY_USING_OUTPUT_OF_NON_PRIMEABLE_WIRE, shared_1.LLSRange.fromLWCSourceLocation(funcObj.location), [updatedWireInfo.propName ? updatedWireInfo.propName : '']), this.fileNamesMap.get('js')));
+            }
+        }
+        return diagnostics;
+    }
+    findUnresolvableWireAdaptersFromImports(funcObj, imports) {
+        let unresolvableImport;
+        let importRef;
+        if (imports &&
+            funcObj.type === shared_1.WIRE_FUNCTION &&
+            funcObj.reference.type === 'ImportReference' &&
+            funcObj.location) {
+            // funcObj.location.
+            importRef = funcObj.reference.value; // ex: "2/names/0"
+            const importIndexArray = importRef.split('/');
+            // + operator converts string to number
+            const importIdx = +importIndexArray[0];
+            const nameIdx = +importIndexArray[2];
+            const komaciImport = imports[importIdx];
+            const importName = komaciImport.names[nameIdx];
+            if (!((0, shared_1.isSupportedNamespace)(komaciImport.resourceName) &&
+                (0, shared_1.isSupportedWireAdapter)(komaciImport.resourceName, imports[importIdx].names[nameIdx]))) {
+                unresolvableImport = {
+                    name: importName,
+                    namespace: imports[importIdx].resourceName,
+                    location: funcObj.location,
+                };
+            }
+        }
+        else if (funcObj.type === shared_1.WIRE_FUNCTION &&
+            funcObj.reference.type === 'Unresolved' &&
+            funcObj.location) {
+            // this handles the corner case where an import wasn't declared, such that wire adapter's function reference type is "Unresolved"
+            unresolvableImport = {
+                name: 'unresolved',
+                namespace: 'unresolved',
+                location: funcObj.location,
+            };
+        }
+        let diagnostic;
+        if (unresolvableImport) {
+            const range = shared_1.LLSRange.fromLWCSourceLocation(unresolvableImport.location);
+            if (unresolvableImport.name !== 'unresolved' &&
+                unresolvableImport.namespace !== 'unresolved') {
+                diagnostic = (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_WIRE_ADAPTER_OF_RESOURCE_CANNOT_BE_PRIMED, range, [unresolvableImport.name, unresolvableImport.namespace]);
+                (0, rules_1.updatePrimingDiagnosticWithFileInfo)(diagnostic, this.fileNamesMap.get('js'));
+            }
+            else {
+                diagnostic = (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_MISSING_RESOURCE_CANNOT_PRIME_WIRE_ADAPTER, range, []);
+                (0, rules_1.updatePrimingDiagnosticWithFileInfo)(diagnostic, this.fileNamesMap.get('js'));
+            }
+        }
+        return diagnostic;
+    }
+    findWireConfigGetterReturningNonLiteral(adg, func) {
+        const diagnostics = [];
+        if (adg.properties) {
+            if (func.type === shared_1.WIRE_FUNCTION && func.input && func.location) {
+                for (const inputProp of func.input) {
+                    if (inputProp.type === 'ObjectValue') {
+                        // inputProp.value = { recordId: {type: "", value: ""}}
+                        for (const wireCfgPropKey in inputProp.value) {
+                            const prop = inputProp.value[wireCfgPropKey];
+                            if (prop.type === 'PropertyReference') {
+                                const adgPropName = prop.value.split('/')[0];
+                                if (adg.properties[adgPropName]?.input?.type ===
+                                    'Unresolved') {
+                                    diagnostics.push((0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_WIRE_CONFIG_PROPERTY_USES_GETTER_FUNCTION_RETURNING_NON_LITERAL, shared_1.LLSRange.fromLWCSourceLocation(func.location), [adgPropName]), this.fileNamesMap.get('js')));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return diagnostics;
+    }
+    findWireConfigForGetterReturningInaccessibleImports(adg, func, imports) {
+        const diagnostics = [];
+        if (adg.properties &&
+            func.type === shared_1.WIRE_FUNCTION &&
+            imports &&
+            func.input &&
+            func.location) {
+            for (const inputProp of func.input) {
+                if (inputProp.type === 'ObjectValue') {
+                    // inputProp.value = { recordId: {type: "", value: ""}}
+                    for (const propName in inputProp.value) {
+                        const prop = inputProp.value[propName];
+                        if (prop.type === 'PropertyReference') {
+                            const adgPropName = prop.value.split('/')[0];
+                            const property = adg.properties[adgPropName];
+                            if (property?.input?.type === 'ImportReference') {
+                                const importsArrIdx = +property.input?.value.split('/')[0];
+                                const resourceName = imports[importsArrIdx].resourceName;
+                                if (!(0, shared_1.isSupportedNamespace)(resourceName)) {
+                                    diagnostics.push((0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_WIRE_CONFIG_PROPERTY_USES_GETTER_FUNCTION_RETURNING_INACCESSIBLE_IMPORT, shared_1.LLSRange.fromLWCSourceLocation(func.location), [adgPropName]), this.fileNamesMap.get('js')));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return diagnostics;
+    }
+    findUnresolvedParentClass(adg) {
+        let diagnostic;
+        if (adg?.parentClass?.type === 'Unresolved') {
+            const range = shared_1.LLSRange.fromLWCSourceLocation(adg?.parentClass?.location);
+            diagnostic = (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_UNRESOLVED_PARENT_CLASS_REFERENCE, range, []);
+        }
+        if (diagnostic) {
+            (0, rules_1.updatePrimingDiagnosticWithFileInfo)(diagnostic, this.fileNamesMap.get('js'));
+        }
+        return diagnostic;
+    }
+    findParentClassFromUnsupportedNS(adg, imports) {
+        let diagnostic;
+        let importRef;
+        if (adg?.parentClass?.type === 'ImportReference' && imports) {
+            importRef = adg?.parentClass?.value;
+            const importIndexArray = importRef.split('/');
+            const importIdx = +importIndexArray[0]; // + operator converts string to number
+            const myImport = imports[importIdx];
+            if (!(0, shared_1.isSupportedNamespace)(myImport.resourceName)) {
+                const range = shared_1.LLSRange.fromLWCSourceLocation(adg?.parentClass?.location);
+                diagnostic = (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_CLASS_REFERS_TO_PARENT_CLASS_FROM_UNSUPPORTED_NAMESPACE, range, []);
+                (0, rules_1.updatePrimingDiagnosticWithFileInfo)(diagnostic, this.fileNamesMap.get('js'));
+            }
+        }
+        return diagnostic;
+    }
+    findWiresWithReactivePropNameFromUnsupportedNS(func, imports) {
+        const diagnostics = [];
+        if (func.type === shared_1.WIRE_FUNCTION && func.input && func.location && imports) {
+            for (const inputObj of func.input) {
+                if (inputObj.type === 'ObjectValue' && inputObj.value) {
+                    for (const inputProp in inputObj.value) {
+                        if (inputProp) {
+                            if (inputObj.value[inputProp].type === 'ImportReference') {
+                                const importNames = this.findImport(imports, inputObj.value[inputProp]);
+                                if (!(0, shared_1.isSupportedNamespace)(importNames[1])) {
+                                    diagnostics.push((0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_WIRE_CONFIG_PROPERTY_USES_IMPORTED_ARTIFACT_FROM_UNSUPPORTED_NAMESPACE, shared_1.LLSRange.fromLWCSourceLocation(func.location), [importNames[0], importNames[1]]), this.fileNamesMap.get('js')));
+                                }
+                            }
+                            else if (inputObj.value[inputProp].type === 'ArrayValue') {
+                                const input = inputObj.value[inputProp];
+                                // if nested within array, recurse to identify any unsupported ns
+                                diagnostics.push(...this.findNestedUnsupportedNSArray(input, imports, func.location));
+                            }
+                            else if (inputObj.value[inputProp].type === 'ObjectValue') {
+                                const input = inputObj.value[inputProp];
+                                // if nested within object, recurse to identify any unsupported ns
+                                diagnostics.push(...this.findNestedUnsupportedNSObject(input, imports, func.location));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return diagnostics;
+    }
+    /**
+     * identify unsupported namespaces usage nested within wireConfig array property
+     */
+    findNestedUnsupportedNSArray(input, imports, loc) {
+        const diagnostics = [];
+        const array = input.value;
+        for (const property of array) {
+            if (property.type === 'ArrayValue') {
+                // if nested further, continue recursion
+                const newInput = property;
+                diagnostics.push(...this.findNestedUnsupportedNSArray(newInput, imports, loc));
+            }
+            else if (property.type === 'ObjectValue') {
+                // if nested further, continue recursion
+                const newInput = property;
+                diagnostics.push(...this.findNestedUnsupportedNSObject(newInput, imports, loc));
+            }
+            else if (property.type === 'ImportReference') {
+                const importNames = this.findImport(imports, property);
+                if (!(0, shared_1.isSupportedNamespace)(importNames[1])) {
+                    diagnostics.push((0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_WIRE_CONFIG_PROPERTY_USES_IMPORTED_ARTIFACT_FROM_UNSUPPORTED_NAMESPACE, shared_1.LLSRange.fromLWCSourceLocation(loc), [importNames[0], importNames[1]]), this.fileNamesMap.get('js')));
+                }
+            }
+        }
+        return diagnostics;
+    }
+    /**
+     * identify unsupported namespaces usage nested within wireConfig object property
+     */
+    findNestedUnsupportedNSObject(input, imports, loc) {
+        const diagnostics = [];
+        const object = input.value;
+        Object.keys(object).forEach((key) => {
+            if (object[key].type === 'ImportReference') {
+                const importNames = this.findImport(imports, object[key]);
+                if (!(0, shared_1.isSupportedNamespace)(importNames[1])) {
+                    diagnostics.push((0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_WIRE_CONFIG_PROPERTY_USES_IMPORTED_ARTIFACT_FROM_UNSUPPORTED_NAMESPACE, shared_1.LLSRange.fromLWCSourceLocation(loc), [importNames[0], importNames[1]]), this.fileNamesMap.get('js')));
+                }
+            }
+            else if (object[key].type === 'ArrayValue') {
+                // if nested further, continue recursion
+                const newInput = object[key];
+                diagnostics.push(...this.findNestedUnsupportedNSArray(newInput, imports, loc));
+            }
+            else if (object[key].type === 'ObjectValue') {
+                // if nested further, continue recursion
+                const newInput = object[key];
+                diagnostics.push(...this.findNestedUnsupportedNSObject(newInput, imports, loc));
+            }
+        });
+        return diagnostics;
+    }
+    findWireConfigReferenceNonExistProperty(adg, func) {
+        const diagnostics = [];
+        if (func.type === shared_1.WIRE_FUNCTION && func.input && func.location) {
+            for (const inputObj of func.input) {
+                if (inputObj.type === 'ObjectValue' && inputObj.value) {
+                    for (const propName in inputObj.value) {
+                        const prop = inputObj.value[propName];
+                        if (prop.type === 'PropertyReference') {
+                            const propName = prop.value.split('/')[0];
+                            if (!adg.properties ||
+                                adg.properties[propName] === undefined) {
+                                diagnostics.push((0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_WIRE_CONFIG_REFERENCES_NON_LOCAL_PROPERTY_REACTIVE_VALUE, shared_1.LLSRange.fromLWCSourceLocation(func.location), [propName]), this.fileNamesMap.get('js')));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return diagnostics;
+    }
+    /**
+     * Produce diagnostics for iterators which iterate on unresolvable inputs, such as private properties
+     * or wired properties which associated to unresolvable wires
+     */
+    findUnresolvableIterator(composition, adgs) {
+        if (composition.type === 'Iteration') {
+            const iteration = composition;
+            const propName = iteration.input.value.split('/')[0];
+            for (const wire of this.orderedWireInfos) {
+                if (wire.propName === propName &&
+                    wire.isNonAnalyzable &&
+                    adgs.includes(wire.adg)) {
+                    return (0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_ITERATE_ON_UNANALYZABLE_PROPERTY_FROM_UNRESOLVABLE_WIRE, shared_1.LLSRange.fromLWCSourceLocation(composition.location), [propName]), this.fileNamesMap.get('html'));
+                }
+            }
+            for (const adg of adgs) {
+                if (adg.properties && adg.properties[propName]) {
+                    const prop = adg.properties[propName];
+                    if (prop.input) {
+                        if (prop.input.type === 'Unresolved') {
+                            return (0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_ITERATE_ON_UNANALYZABLE_GETTER_PROPERTY, shared_1.LLSRange.fromLWCSourceLocation(composition.location), [propName]), this.fileNamesMap.get('html'));
+                        }
+                    }
+                    else {
+                        if (!prop.isPublic) {
+                            return (0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_CONDITIONAL_USING_UNANALYZABLE_NON_PUBLIC_PROPERTY, shared_1.LLSRange.fromLWCSourceLocation(composition.location), [propName]), this.fileNamesMap.get('html'));
+                        }
+                    }
+                }
+            }
+        }
+        return;
+    }
+    /**
+     * Produce diagnostics for conditionals which act upon unresolvable inputs, such as private properties
+     * or wired properties which associated to unresolvable wires
+     */
+    findUnresolvableConditional(composition, adgs) {
+        if (composition.type === 'Container') {
+            if (composition.isActive) {
+                const propName = composition.isActive.input.value.split('/')[0];
+                for (const wire of this.orderedWireInfos) {
+                    if (wire.propName === propName &&
+                        wire.isNonAnalyzable &&
+                        adgs.includes(wire.adg)) {
+                        const fileNameHTML = this.fileNamesMap.get('html');
+                        return (0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_CONDITIONAL_USING_PROPERTY_FROM_UNRESOLVABLE_WIRE, shared_1.LLSRange.fromLWCSourceLocation(composition.location), [propName]), fileNameHTML);
+                    }
+                }
+                for (const adg of adgs) {
+                    if (adg.properties && adg.properties[propName]) {
+                        const prop = adg.properties[propName];
+                        if (prop.input) {
+                            if (prop.input.type === 'Unresolved') {
+                                return (0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_CONDITIONAL_ON_UNANALYZABLE_GETTER_PROPERTY, shared_1.LLSRange.fromLWCSourceLocation(composition.location), [propName]), this.fileNamesMap.get('html'));
+                            }
+                        }
+                        else {
+                            if (!prop.isPublic) {
+                                return (0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_CONDITIONAL_USING_UNANALYZABLE_NON_PUBLIC_PROPERTY, shared_1.LLSRange.fromLWCSourceLocation(composition.location), [propName]), this.fileNamesMap.get('html'));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return;
+    }
+    /**
+     * 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
+     */
+    findUnresolvableImage(image, adgs) {
+        if ((0, shared_1.isImageComposition)(image)) {
+            if (image.src.type === 'Binding') {
+                const propName = image.src.value;
+                for (const adg of adgs) {
+                    if (adg.properties?.[propName]) {
+                        const prop = adg.properties[propName];
+                        if (prop.initial?.type === 'Unresolved') {
+                            return (0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_IMAGE_REFERENCE_UNANALYZABLE_SOURCE_PROPERTY, 
+                            // TODO: currently is an emptyRange location. May need to add support
+                            // for location of image tags. Created work item W-11309043 for this
+                            shared_1.LLSRange.fromLWCSourceLocation(image.location), [propName]), this.fileNamesMap.get('html'));
+                        }
+                    }
+                    else {
+                        // property in image src attribute is not found in the script file, so return a dianostic
+                        // for this situation too.
+                        return (0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_IMAGE_REFERENCE_MISSING_SOURCE_PROPERTY, 
+                        // TODO: currently is an emptyRange location. May need to add support
+                        // for location of image tags. Created work item W-11309043 for this
+                        shared_1.LLSRange.fromLWCSourceLocation(image.location), [propName]), this.fileNamesMap.get('html'));
+                    }
+                }
+            }
+        }
+        return;
+    }
+    /**
+     * Convert array of Compositions into flattened array of Compositions,
+     * visiting top-level and nested children compositions
+     */
+    compositionsToArray(compositions) {
+        const compositionArray = [];
+        compositions.forEach((node) => {
+            compositionArray.push(node);
+            if (node.compositions) {
+                compositionArray.push(...this.compositionsToArray(node.compositions));
+            }
+        });
+        return compositionArray;
+    }
+    /**
+     * find Import name information (resourceName, importName) given komaciDoc imports and reference
+     */
+    findImport(imports, property) {
+        const importRef = property.value; // casting as expecting string type
+        const importIndexArray = importRef.split('/');
+        const importIdx = +importIndexArray[0]; // + operator converts string to number
+        const nameIdx = +importIndexArray[2];
+        const myImport = imports[importIdx];
+        const importName = myImport.names[nameIdx];
+        return [importName, myImport.resourceName];
+    }
+    getMetadata(input) {
+        let bundleMetadata;
+        // using a type guard to distinguish between interface types
+        if (input.type === 'file') {
+            bundleMetadata = collector.collectBundleMetadata({
+                namespace: input.namespace,
+                name: input.name,
+                type: 'platform',
+                namespaceMapping: {},
+                files: [{ fileName: input.fileName, source: input.sourceFile }],
+                enableKomaci: true,
+            });
+        }
+        else if (input.type === 'bundle') {
+            const fileEntries = [];
+            for (const filename in input.files) {
+                fileEntries.push({
+                    fileName: filename,
+                    source: input.files[filename],
+                });
+            }
+            bundleMetadata = collector.collectBundleMetadata({
+                namespace: input.namespace,
+                name: input.name,
+                type: 'platform',
+                namespaceMapping: {},
+                files: fileEntries,
+                enableKomaci: true,
+            });
+        }
+        else {
+            throw new Error(shared_1.ERROR_PREFIX + 'invalid input type. Cannot retrieve metadata from input.');
+        }
+        return bundleMetadata;
+    }
+    findWireConfigReferenceCircularDependency() {
+        const linkedWireInfos = [];
+        this.wireInfoMap.forEach((wireInfo) => {
+            linkedWireInfos.push(wireInfo);
+        });
+        const dependencyGraph = new WireGraph_1.WireGraph(linkedWireInfos);
+        if (dependencyGraph.hasCycle()) {
+            const wire = dependencyGraph.getWireThatCycles();
+            if (wire && wire.wireFunction && wire.wireFunction.location) {
+                return (0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_WIRE_CONFIG_PROPERTY_CIRCULAR_WIRE_DEPENDENCY, shared_1.LLSRange.fromLWCSourceLocation(wire.wireFunction.location), [
+                    dependencyGraph.getWireCycleProperty(),
+                    dependencyGraph.getWireCycleString(),
+                ]), this.fileNamesMap.get('js'));
+            }
+        }
+        return undefined;
+    }
+    /**
+     * 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
+     */
+    reorderFunctionsByWireDependency(adg, funcs) {
+        const srcOrderedWireInfos = [];
+        for (const funcIdx in funcs) {
+            // build up the wireInfos and buid dependency list
+            if (funcs[funcIdx].type === 'WireFunction' && adg.properties) {
+                // find or create WireInfo associated with function
+                const wireInfo = this.findWireInfo(+funcIdx, adg, funcs);
+                srcOrderedWireInfos.push(wireInfo);
+                // find dependencies of the WireInfo, and create those and add to the original wireInfo
+                const funcInputArray = funcs[funcIdx].input;
+                if (funcInputArray &&
+                    funcInputArray[0] &&
+                    funcInputArray[0].type === 'ObjectValue' &&
+                    funcInputArray[0].value) {
+                    // per Komaci spec: "The input of the function is an array with a single element of type object"
+                    // so we can assume a single input in the input array passed to this method
+                    for (const configObj of Object.values(funcInputArray[0].value)) {
+                        if (configObj.type === 'PropertyReference') {
+                            const propToEval = configObj.value;
+                            const propToEvalParsed = propToEval.split('/');
+                            for (const [propName, propValue] of Object.entries(adg.properties)) {
+                                // does the wire config property refer to another wire?
+                                if (propName === propToEvalParsed[0] && // we only care about top level property. ex: wireOutput1 from wireOutput1/data
+                                    propValue.input?.type === 'FunctionReference') {
+                                    // add the depWireInfo that the wireInfo depends on
+                                    const funcIdx = propValue.input.value;
+                                    wireInfo.dependentWires.push(this.findWireInfo(+funcIdx, adg, funcs));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return srcOrderedWireInfos.sort((wire1, wire2) => {
+            if (this.dependsOn(wire1, wire2) && this.dependsOn(wire2, wire1)) {
+                return 0;
+            }
+            else if (this.dependsOn(wire1, wire2)) {
+                return 1;
+            }
+            else if (this.dependsOn(wire2, wire1)) {
+                return -1;
+            }
+            return 0;
+        });
+    }
+    // comparator function compatible with Array.sort() method
+    // Determines if wire1 depends on wire2
+    dependsOn(wire1, wire2) {
+        for (const index in wire1.dependentWires) {
+            const depWire = wire1.dependentWires[index];
+            if (wire2.funcIndex === depWire.funcIndex) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // acquire wired property name and use to create WireInfo, if not already created
+    findWireInfo(index, adg, funcs) {
+        let wireInfo = this.wireInfoMap.get(index);
+        if (!wireInfo) {
+            // find property name
+            let propertyName = undefined;
+            for (const propName in adg.properties) {
+                if (adg.properties[propName].input?.type === 'FunctionReference' &&
+                    adg.properties[propName].input?.value === index) {
+                    propertyName = propName;
+                    break;
+                }
+            }
+            // create new WireInfo
+            wireInfo = {
+                funcIndex: index,
+                isNonAnalyzable: false,
+                dependentWires: [],
+                location: undefined,
+                wireFunction: funcs[index],
+                propName: propertyName,
+                adg: adg,
+                beingVisited: false,
+                visited: false,
+            };
+            this.wireInfoMap.set(index, wireInfo);
+        }
+        return wireInfo;
+    }
+}
+exports.StaticAnalyzer = StaticAnalyzer;
+//# sourceMappingURL=staticAnalyzer.js.map