@komaci/static-analyzer 240.1.3 → 242.1.0

package/build/shared.d.ts

@@ -1,26 +1,18 @@
-import { ClassPropertyContexts } from '@komaci/common-shared';
-import { GetPrimingAdapter } from './types';
+import * as t from '@babel/types';
+import { ModuleContext } from '@komaci/common-shared';
+import { GetterDiagnosticsContext, TemplateDiagnosticsContext } from './types';
 import { SourceLocation } from '@babel/types';
-import { PrimingDiagnostic, Range } from '.';
+import { Range } from '.';
 import { Composition, Image, SourceLocation as KomaciSourceLocation } from '@komaci/types';
+import { ModuleMetadata } from '@komaci/common-shared';
 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
@@ -38,11 +30,23 @@ export declare const LLSRange: {
     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.
+ * Function to analyze src code and returns any diagnostics found and valid getter contexts in a GetterDiagnosticContext
+ * @param adgIndex index of the current adg to process
+ * @param rootAst the Abstract Syntax Tree for the component
+ * @param moduleMetadata metadata about the given component
+ * @param moduleContext contextual details about the component, like module level variables, etc
+ * @returns diagnostics for the getters
+ */
+export declare function analyzeSrcForInvalidGetterFunctions(adgIndex: number, rootAst: t.File, moduleMetadata: ModuleMetadata, moduleContext: ModuleContext): GetterDiagnosticsContext;
+/**
+ * Function to analyze tempplate strings and collect any Priming Diagnostic info for them along with returning valid templates contexts
+ * @param adgIndex index of the current adg to process
+ * @param rootAst the Abstract Syntax Tree for the component
+ * @param moduleMetadata metadata about the given component
+ * @param moduleContext contextual details about the component, like module level variables, etc
+ * @returns diagnostics for the template strings
  */
-export declare function analyzeSrcForInvalidGetterFunctions(srcCode: string, namespace: string, properties: ClassPropertyContexts): PrimingDiagnostic[];
+export declare function analyzeSrcForTemplateStringDiagnostics(adgIndex: number, rootAst: t.File, moduleMetadata: ModuleMetadata, moduleContext: ModuleContext): TemplateDiagnosticsContext;
 /**
  * Type guard for the komaci Image type
  * @param {Composition} composition the komaci Composition object

package/build/shared.js

@@ -1,9 +1,8 @@
 "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");
+exports.isImageComposition = exports.analyzeSrcForTemplateStringDiagnostics = exports.analyzeSrcForInvalidGetterFunctions = exports.LLSRange = exports.isSupportedNamespace = exports.ERROR_PREFIX = exports.WIRE_FUNCTION = void 0;
 const common_shared_1 = require("@komaci/common-shared");
+const _1 = require(".");
 const validateGetter_1 = require("./validateGetter");
 // TODO: eventually refactor list consts into their own file
 exports.WIRE_FUNCTION = 'WireFunction';
@@ -12,44 +11,6 @@ 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
@@ -70,18 +31,6 @@ function isSupportedNamespace(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`) */
@@ -135,43 +84,70 @@ exports.LLSRange = {
     },
 };
 /**
- * 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 to analyze src code and returns any diagnostics found and valid getter contexts in a GetterDiagnosticContext
+ * @param adgIndex index of the current adg to process
+ * @param rootAst the Abstract Syntax Tree for the component
+ * @param moduleMetadata metadata about the given component
+ * @param moduleContext contextual details about the component, like module level variables, etc
+ * @returns diagnostics for the getters
  */
-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),
-    };
+function analyzeSrcForInvalidGetterFunctions(adgIndex, rootAst, moduleMetadata, moduleContext) {
     const diagnostics = [];
+    const validGetters = [];
     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 adg = moduleMetadata.adgs.get(adgIndex);
+    if (getters.length > 0 && adg) {
+        getters.forEach((getterFunc, index) => {
+            const res = (0, validateGetter_1.validateGetter)(getterFunc, adgIndex, moduleMetadata, moduleContext, true);
             const getterDiagnostics = res;
+            //Same thing as passing false into validate getter and getting a boolean back. If there are no diagnostics its valid.
+            if (getterDiagnostics.length == 0) {
+                const validGetter = generateValidGetterContext(getterFunc, adgIndex, moduleMetadata, index);
+                validGetters.push(validGetter);
+                const name = (0, common_shared_1.getClassMethodName)(getterFunc);
+                (0, common_shared_1.updatePropertyUsage)(name, validGetter.memberUsage, adg.properties, common_shared_1.PropertyTypes.GETTER);
+            }
             diagnostics.push(...getterDiagnostics);
         });
     }
-    return diagnostics;
+    return {
+        getterFunctionDiagnostics: diagnostics,
+        validGetters: validGetters,
+    };
 }
 exports.analyzeSrcForInvalidGetterFunctions = analyzeSrcForInvalidGetterFunctions;
+/**
+ * Function to analyze tempplate strings and collect any Priming Diagnostic info for them along with returning valid templates contexts
+ * @param adgIndex index of the current adg to process
+ * @param rootAst the Abstract Syntax Tree for the component
+ * @param moduleMetadata metadata about the given component
+ * @param moduleContext contextual details about the component, like module level variables, etc
+ * @returns diagnostics for the template strings
+ */
+function analyzeSrcForTemplateStringDiagnostics(adgIndex, rootAst, moduleMetadata, moduleContext) {
+    const diagnostics = [];
+    const validTemplates = [];
+    const { templateStrings } = (0, common_shared_1.getPropertyMetadataFromAst)(rootAst);
+    const adg = moduleMetadata.adgs.get(adgIndex);
+    if (templateStrings.length > 0 && adg) {
+        templateStrings.forEach((templateString, index) => {
+            const res = (0, _1.validateTemplateString)(templateString, adgIndex, moduleMetadata, moduleContext, true);
+            const templateDiagnostics = res;
+            //Same thing as passing false into validate getter and getting a boolean back. If there are no diagnostics its valid.
+            if (templateDiagnostics.length == 0) {
+                const validTemplate = generateValidTemplateContext(templateString, adgIndex, moduleMetadata, index);
+                validTemplates.push(validTemplate);
+                (0, common_shared_1.updatePropertyUsage)((0, common_shared_1.getFromIdentifierOrStringLiteral)(templateString.node.key), validTemplate.memberUsage, adg.properties, common_shared_1.PropertyTypes.TEMPLATE_STRING);
+            }
+            diagnostics.push(...templateDiagnostics);
+        });
+    }
+    return {
+        templateDiagnostics: diagnostics,
+        validTemplates: validTemplates,
+    };
+}
+exports.analyzeSrcForTemplateStringDiagnostics = analyzeSrcForTemplateStringDiagnostics;
 /**
  * Type guard for the komaci Image type
  * @param {Composition} composition the komaci Composition object
@@ -181,4 +157,39 @@ function isImageComposition(composition) {
     return composition.type === 'Image';
 }
 exports.isImageComposition = isImageComposition;
+/**
+ * Helper function to generate a validGetterContext
+ * @param getterFunc the valid getter function
+ * @param moduleContext the module context
+ * @param moduleLevelConsumption a moduleLevelConsumption object
+ * @param properties properties array
+ * @param index index of the getter function
+ * @returns a valid getter context
+ */
+function generateValidGetterContext(getterFunc, adgIndex, moduleMetadata, index) {
+    const { identifiers } = (0, common_shared_1.implicitConsumptionMetadata)(getterFunc, adgIndex, moduleMetadata);
+    const validGetter = {
+        getter: getterFunc,
+        generatedName: `g${index}`,
+        memberUsage: identifiers,
+    };
+    return validGetter;
+}
+/**
+ * Helper function to generate a validTemplateContext
+ * @param template the valid template string
+ * @param moduleContext the module context
+ * @param moduleLevelConsumption a moduleLevelConsumption object
+ * @param properties properties array
+ * @param index index of the template string
+ * @returns a valid template context
+ */
+function generateValidTemplateContext(template, adgIndex, moduleMetadata, index) {
+    const { identifiers } = (0, common_shared_1.implicitConsumptionMetadata)(template, adgIndex, moduleMetadata);
+    return {
+        template,
+        generatedName: `t${index}`,
+        memberUsage: identifiers,
+    };
+}
 //# sourceMappingURL=shared.js.map

package/build/staticAnalyzer.d.ts

@@ -1,3 +1,4 @@
+import { KomaciDocument } from '@komaci/types';
 import { AnalyzerInput, PrimingDiagnostic, Range, Position, WireInfo } from './types';
 export declare class StaticAnalyzer {
     startPos: Position;
@@ -27,7 +28,7 @@ export declare class StaticAnalyzer {
      * @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;
+    processKomaciTemplateDoc(templateKomaciDoc: KomaciDocument | undefined, scriptKomaciDoc: KomaciDocument | undefined, diagnostics: PrimingDiagnostic[]): PrimingDiagnostic[];
     private findWireConfigsThatUsePrivateProperty;
     /**
      * Traverses direct dependencies of the input wire (represented by a WireInfo) to see if any
@@ -55,29 +56,16 @@ export declare class StaticAnalyzer {
     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
+     * Produce diagnostics for compositions which use unresolvable inputs, such as private properties
+     * or wired properties which associated to unresolvable wires.
      *
-     * @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
+     * @param properties the properties array
+     * @param adgs the adgs associated with the template
+     * @param diagnosics the diagnosics array
+     * @param defaultHasParent if the default expored ADG inherent a parent class
+     * @returns void
      */
-    private compositionsToArray;
+    private findUnresolvableCompositionProperty;
     /**
      * find Import name information (resourceName, importName) given komaciDoc imports and reference
      */

package/build/staticAnalyzer.js

@@ -1,7 +1,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -20,11 +24,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StaticAnalyzer = void 0;
-const collector = __importStar(require("@lwc-platform/lwc-metadata-next"));
+const collector = __importStar(require("@lwc/metadata"));
 const rules_1 = require("./rules");
 const common_shared_1 = require("@komaci/common-shared");
 const shared_1 = require("./shared");
 const WireGraph_1 = require("./WireGraph");
+const helpers_1 = require("./helpers");
 class StaticAnalyzer {
     constructor() {
         // TODO: Remove this sample Range when it is no longer needed as a placeholder
@@ -78,17 +83,38 @@ class StaticAnalyzer {
                         }
                     }
                 }
-                if (sourceFileName && scriptKomaciDoc) {
-                    const properties = (0, common_shared_1.collectPropertyMetadataFromScriptDoc)(scriptKomaciDoc);
-                    if (templateKomaciDoc) {
-                        (0, common_shared_1.updatePropertyMetadataFromTemplateDoc)(templateKomaciDoc, properties);
-                    }
+                const adgIndex = scriptKomaciDoc?.exports?.default?.value;
+                const defaultAdg = scriptKomaciDoc?.adgs?.[adgIndex || 0];
+                if (sourceFileName &&
+                    scriptKomaciDoc &&
+                    adgIndex !== undefined &&
+                    defaultAdg) {
+                    const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+                    (0, common_shared_1.initializeImportMetdataFromKomaciDocument)(scriptKomaciDoc, moduleMetadata);
+                    const adg = (0, common_shared_1.initAdgMetadataObject)('adg0');
+                    moduleMetadata.adgs.set(adgIndex, adg);
+                    (0, common_shared_1.initializePropertiesMap)(defaultAdg.properties, defaultAdg.functions, adgIndex, scriptKomaciDoc, moduleMetadata);
                     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);
+                    const rootAst = (0, common_shared_1.generateAstFromSrcCode)(srcCode);
+                    (0, common_shared_1.collectImportMetadataFromAst)(rootAst, moduleMetadata);
+                    const moduleContext = {
+                        astContext: (0, common_shared_1.getAstContextObject)(rootAst),
+                        isExternal: (0, common_shared_1.isExternalModule)(input.namespace),
+                    };
+                    const { getterFunctionDiagnostics, validGetters } = (0, shared_1.analyzeSrcForInvalidGetterFunctions)(adgIndex, rootAst, moduleMetadata, moduleContext);
+                    const { templateDiagnostics, validTemplates } = (0, shared_1.analyzeSrcForTemplateStringDiagnostics)(adgIndex, rootAst, moduleMetadata, moduleContext);
+                    const getterAndTemplateDiagnostics = [
+                        ...getterFunctionDiagnostics,
+                        ...templateDiagnostics,
+                    ];
+                    if (getterAndTemplateDiagnostics.length > 0) {
+                        getterAndTemplateDiagnostics.forEach((diagnostic) => {
+                            (0, rules_1.updatePrimingDiagnosticWithFileInfo)(diagnostic, sourceFileName);
+                            diagnostics.push(diagnostic);
+                        });
                     }
+                    (0, common_shared_1.updateKomaciDocumentWithValidGetters)(scriptKomaciDoc, validGetters);
+                    (0, common_shared_1.updateKomaciDocumentWithValidTemplatedStrings)(scriptKomaciDoc, validTemplates);
                 }
                 this.processKomaciScriptDoc(scriptKomaciDoc, diagnostics);
                 this.processKomaciTemplateDoc(templateKomaciDoc, scriptKomaciDoc, diagnostics);
@@ -117,13 +143,32 @@ class StaticAnalyzer {
             // 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 adgIndex = komaciDoc?.exports?.default?.value;
+            const defaultAdg = komaciDoc?.adgs?.[adgIndex || 0];
+            if (komaciDoc && adgIndex !== undefined && defaultAdg) {
+                const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+                (0, common_shared_1.initializeImportMetdataFromKomaciDocument)(komaciDoc, moduleMetadata);
+                const adg = (0, common_shared_1.initAdgMetadataObject)('adg0');
+                moduleMetadata.adgs.set(adgIndex, adg);
+                (0, common_shared_1.initializePropertiesMap)(defaultAdg.properties, defaultAdg.functions, adgIndex, komaciDoc, moduleMetadata);
                 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);
+                const rootAst = (0, common_shared_1.generateAstFromSrcCode)(srcCode);
+                (0, common_shared_1.collectImportMetadataFromAst)(rootAst, moduleMetadata);
+                const moduleContext = {
+                    astContext: (0, common_shared_1.getAstContextObject)(rootAst),
+                    isExternal: (0, common_shared_1.isExternalModule)(input.namespace),
+                };
+                const { getterFunctionDiagnostics } = (0, shared_1.analyzeSrcForInvalidGetterFunctions)(adgIndex, rootAst, moduleMetadata, moduleContext);
+                const { templateDiagnostics } = (0, shared_1.analyzeSrcForTemplateStringDiagnostics)(adgIndex, rootAst, moduleMetadata, moduleContext);
+                const getterAndTemplateDiagnostics = [
+                    ...getterFunctionDiagnostics,
+                    ...templateDiagnostics,
+                ];
+                if (getterAndTemplateDiagnostics.length > 0) {
+                    getterAndTemplateDiagnostics.forEach((diagnostic) => {
+                        (0, rules_1.updatePrimingDiagnosticWithFileInfo)(diagnostic, this.fileNamesMap.get('js'));
+                        diagnostics.push(diagnostic);
+                    });
                 }
             }
             return this.processKomaciScriptDoc(komaciDoc, diagnostics);
@@ -220,34 +265,20 @@ class StaticAnalyzer {
             scriptKomaciDoc?.exports) {
             const adgs = [];
             const defaultExport = scriptKomaciDoc.exports['default'];
+            let defaultHasParent = false;
             if (defaultExport && defaultExport.type === 'AdgReference') {
                 const defaultAdg = scriptKomaciDoc.adgs[defaultExport.value];
                 adgs.push(defaultAdg);
                 let parentClass = defaultAdg.parentClass;
                 while (parentClass?.type === 'AdgReference') {
+                    defaultHasParent = true;
                     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);
-                }
-            }
+            const properties = (0, helpers_1.findPropertiesUsedInCompositions)(templateKomaciDoc.compositions);
+            this.findUnresolvableCompositionProperty(properties, adgs, diagnostics, defaultHasParent);
         }
         return diagnostics;
     }
@@ -326,7 +357,7 @@ class StaticAnalyzer {
             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]))) {
+                (0, common_shared_1.isSupportedWireAdapter)(komaciImport.resourceName, imports[importIdx].names[nameIdx]))) {
                 unresolvableImport = {
                     name: importName,
                     namespace: imports[importIdx].resourceName,
@@ -541,121 +572,50 @@ class StaticAnalyzer {
         return diagnostics;
     }
     /**
-     * Produce diagnostics for iterators which iterate on unresolvable inputs, such as private properties
-     * or wired properties which associated to unresolvable wires
+     * Produce diagnostics for compositions which use unresolvable inputs, such as private properties
+     * or wired properties which associated to unresolvable wires.
+     *
+     * @param properties the properties array
+     * @param adgs the adgs associated with the template
+     * @param diagnosics the diagnosics array
+     * @param defaultHasParent if the default expored ADG inherent a parent class
+     * @returns void
      */
-    findUnresolvableIterator(composition, adgs) {
-        if (composition.type === 'Iteration') {
-            const iteration = composition;
-            const propName = iteration.input.value.split('/')[0];
+    findUnresolvableCompositionProperty(properties, adgs, diagnosics, defaultHasParent) {
+        for (const compositionProperty of properties) {
+            const { propertyName, diagnosticMessageAct, location } = compositionProperty;
             for (const wire of this.orderedWireInfos) {
-                if (wire.propName === propName &&
+                if (wire.propName === propertyName &&
                     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'));
+                    // property on unresolvable wire
+                    diagnosics.push((0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_COMPOSITION_ON_UNANALYZABLE_PROPERTY_FROM_UNRESOLVABLE_WIRE, shared_1.LLSRange.fromLWCSourceLocation(location), [diagnosticMessageAct, propertyName]), this.fileNamesMap.get('html')));
                 }
             }
+            let propertyFound = false;
             for (const adg of adgs) {
-                if (adg.properties && adg.properties[propName]) {
-                    const prop = adg.properties[propName];
+                if (adg.properties && adg.properties[propertyName]) {
+                    propertyFound = true;
+                    const prop = adg.properties[propertyName];
                     if (prop.input) {
+                        // getter
                         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'));
+                            diagnosics.push((0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_COMPOSITION_ON_UNANALYZABLE_GETTER_PROPERTY, shared_1.LLSRange.fromLWCSourceLocation(location), [diagnosticMessageAct, propertyName]), 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'));
-                            }
+                            // private property
+                            diagnosics.push((0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_COMPOSITION_ON_UNANALYZABLE_PROPERTY_NON_PUBLIC, shared_1.LLSRange.fromLWCSourceLocation(location), [diagnosticMessageAct, propertyName]), 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'));
-                    }
-                }
+            if (!propertyFound && !defaultHasParent) {
+                // property not exist
+                diagnosics.push((0, rules_1.updatePrimingDiagnosticWithFileInfo)((0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_COMPOSITION_ON_UNANALYZABLE_PROPERTY_MISSING, shared_1.LLSRange.fromLWCSourceLocation(location), [diagnosticMessageAct, propertyName]), 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