@komaci/common-shared 240.1.5 → 242.1.1

package/build/types.d.ts

@@ -1,77 +1,50 @@
 import { NodePath } from '@babel/traverse';
 import * as t from '@babel/types';
-import { PrimitiveValue, PropertyReference, UnresolvedValue, ImportReference as KomaciDocImportReference, Binding } from '@komaci/types';
-/**
- * @typedef ClassPropertyInfo is an object that holds information about a class property
- * @property {t.ClassProperty | t.ClassMethod | NodePath<t.ClassProperty | t.ClassMethod>} classProp is the class property babel object.
- * @property {string} classPropId is the id of the class property.
- * @property {string} decoratorType is the type of decorate. Ex: api, track, wire
- * @property {boolean} isDecorated whether this class property is decorated or not
- * @property {boolean} hasInitialValue whether this class property has an initial value
- */
-export declare type ClassPropertyInfo = {
-    classProp: t.ClassProperty | t.ClassMethod | NodePath<t.ClassProperty | t.ClassMethod>;
-    classPropId: string;
-    decoratorType?: string;
-    isDecorated: boolean;
-    hasInitialValue: boolean;
-};
-/**
- * @typedef ValidGetterContext is an object that holds information about the member varaibles within a getter function.
- * @property {NodePath<t.ClassMethod>} getter is the babel object for the getter method node.
- * @property {Array<string>} memberUsage is an array of member variable names that are within the getter.
- * @property {number} f_index is the index at which this getter was added to the functions array in the Komaci document.
- */
-export declare type ValidGetterContext = {
-    getter: NodePath<t.ClassMethod>;
-    memberUsage: Array<string>;
-    generatedName: string;
-    f_index?: number;
-};
-/**
- * @typedef ValidTemplateContext is an object that holds information about the member varaibles within a template.
- * @property {NodePath<t.ClassProperty>} template is the babel object for the getter method node.
- * @property {Array<string>} memberUsage is an array of member variable names that are within the template.
- * @property {string} generatedName name used as function name in the resolvable module
- * @property {number} f_index is the index at which this template was added to the functions array in the Komaci document.
- */
-export declare type ValidTemplateContext = {
-    template: NodePath<t.ClassProperty>;
-    memberUsage: Array<string>;
-    generatedName: string;
-    f_index?: number;
-};
-/**
- * @typedef ImportDeclarationInfo is an object that holds information about the import declarations
- * @property {string} identifierName is the name of the imported resource.
- * @property {string} namespace Full import source path
- * @property {boolean} isSupported a boolean field to determine if an import is supported or not.
- * @property {boolean} isDefault a boolean field to determine if an import is the default import.
- * @property {boolean} isNamespaceSpecifier a boolean field to determine if an import is a namespace import.
- * @property {string} trueName sometimes imports are renamed so we maintain their true name for later processing
- */
-export declare type ImportDeclarationInfo = {
-    identifierName: string;
-    namespace: string;
-    isSupported: boolean;
-    isDefault: boolean;
-    isNamespaceSpecifier: boolean;
-    trueName?: string;
-};
+import { PrimitiveValue, PropertyReference, UnresolvedValue, ImportReference as KomaciDocImportReference, Binding, KomaciDocument, FunctionType, StaticValue, Adg, Value } from '@komaci/types';
+export declare const ERROR_PREFIX = "[komaci] ";
+export declare const CONTEXT = "ctx";
+export declare const PROPS = "props";
+export declare enum IdKeys {
+    CONTEXT = "CONTEXT",
+    PROPS = "PROPS",
+    FACTORY = "FACTORY",
+    COMPOSED_GRAPH_FUNC = "COMPOSED_GRAPH_FUNC",
+    ITERATION_FUNC = "ITERATION_FUNC",
+    UNRESOLVED_FUNC = "UNRESOLVED_FUNC",
+    SLOT_FUNC = "SLOT_FUNC",
+    ELEMENT_FUNC = "ELEMENT_FUNC",
+    ADG_FUNC = "ADG_FUNC",
+    SLOT = "SLOT",
+    COMPONENT_ID = "COMPONENT_ID",
+    UNDEFINED = "UNDEFINED",
+    PROP_API = "PROP_API",
+    PROP_INIT = "PROP_INIT",
+    PROP_FUNC = "PROP_FUNC",
+    PROP_GETTER = "PROP_GETTER",
+    DEFAULT_COMP = "DEFAULT_COMP",
+    FUNC_ID = "FUNC_ID",
+    FUNC_NAME = "FUNC_NAME",
+    FUNC_TYPE = "FUNC_TYPE",
+    FUNC_CONFIG = "FUNC_CONFIG",
+    FUNC_INPUT = "FUNC_INPUT",
+    WIRE_TYPE = "WIRE_TYPE",
+    UNRESOLVED_VALUE = "UNRESOLVED_VALUE",
+    BATCH_FUNC_ID = "BATCH_FUNC_ID",
+    BATCH_FUNC_NAME = "BATCH_FUNC_NAME",
+    REDUCER_FUNC_ID = "REDUCER_FUNC_ID",
+    IMG_SRC = "IMG_SRC",
+    IMG_FUNC = "IMG_FUNC"
+}
 /**
  * @typedef AstContext is an object that holds meta data information about the ast.
- * @property {Map<string, ImportDeclarationInfo>} importDeclarations a collection of importDeclarationInfo
  * @property {string[]} moduleFunctions is a collection of function names that are defined on the module level.
  * @property {string[]} moduleVariables is a collection of variable names that are defined on the module level.
  * @property {string[]} classFunctions is a collection of functino names that are defined on the class level.
- * @property {string[]} classProperties is a collection of class properties.
  */
 export declare type AstContext = {
-    importDeclarations: Map<string, ImportDeclarationInfo>;
     moduleFunctions: string[];
     moduleVariables: string[];
     classFunctions: string[];
-    classProperties: ClassPropertyInfo[];
 };
 /**
  * Contextual info about all the imports from a specific resource for use in module composition
@@ -90,16 +63,6 @@ export declare type ImportDetail = {
 };
 /** Mapping of resources to contextual info about themselves */
 export declare type ConsumedImports = Map<string, ImportDetail>;
-/** Mapping of specific imports to their general metadata info */
-export declare type ImportDeclarations = Map<string, ImportDeclarationInfo>;
-/**
- * A stateful object to populate across getters for how they consume high level things. like imports.
- *
- * @property {Map} consumedImports all of the imports that getters use. This is uniquely data not retrievable by komaci document.
- */
-export declare type ModuleLevelConsumption = {
-    consumedImports: ConsumedImports;
-};
 /**
  * Metadata about specific things a getter consumed. for later processing
  */
@@ -112,32 +75,38 @@ export declare type ImplicitConsumption = {
 export declare enum PropertyTypes {
     WIRE = "wire",
     GETTER = "getter",
-    INTERNAL = "internal",
-    PUBLIC = "api",
+    BASE = "base",
     IMPORT_REFERENCE = "importReference",
     TEMPLATE_STRING = "templateString"
 }
 /**
  * Contextual information about a property and who consumes it
  */
-export declare type ClassPropertyContext = BasePropertyContext | WirePropertyContext | ImportPropertyContext;
+export declare type ClassPropertyContext = BasePropertyContext | ImportPropertyContext | FunctionalPropertyContext;
 /**
  * Base type for property context
  */
 export declare type BasePropertyContext = {
+    isPublic: boolean;
     /** Type of property */
     type: PropertyTypes;
     /** If this property is used in priming through wires, compositions or implicitly through a getter */
     usedInPriming: boolean;
+    /** Reference which adg this property is defined in  */
+    fromAdg?: number;
+    inital?: StaticValue | PrimitiveValue;
 };
 /**
- * Added metadata specifically for wire properties
+ * When a function is considered unsupported i.e.:
+ * - wire reference is not supported
+ * - getter or template string does not pass purity checks
+ *
+ * we set the f index for property metadata to -1
  */
-export declare type WirePropertyContext = BasePropertyContext & {
-    /** type explicitly set to wire */
-    type: PropertyTypes.WIRE;
-    /** reference to import data */
-    wire: ImportMetadata;
+export declare const UNSUPPORTED_FUNCTION = -1;
+export declare type FunctionalPropertyContext = BasePropertyContext & {
+    /** index of associated function (if there is one). If the function is unsupported in anyway this is set to `UNSUPPORTED_FUNCTION` */
+    functionIndex: number;
 };
 /**
  * Added metadata specifically for properties that get values from imports
@@ -149,14 +118,42 @@ export declare type ImportPropertyContext = BasePropertyContext & {
 /**
  * Basic details about an Import
  */
-export declare type ImportMetadata = {
+export declare type BasicImportMetadata = {
     /** The name of the import as defined in the import object on komaci doc */
     name: string;
+    /** The alias set for an import in the original module. i.e. `import { item as importAlias } from 'importPath'` */
+    importAlias?: string;
+    /** alias generated for the import as part of resolvable module composition. */
+    generatorAlias: string;
     /** The name of the import namespace as defined in the import object on komaci doc */
     resourceName: string;
     /** The referential id for this import. i.e. 0/names/0 */
     komaciDocImportRef: string;
+    /** flag representing if this import is from a namespace we support */
+    isFromInternalNamespace: boolean;
+    /** flag representing if the import is from a library we support (used for pure functions i.e. getters and template string inflation) */
+    isFromSupportedLibrary: boolean;
+    /** flag representing if this import is used as part of priming (in a wire, as part of a pure function, initial value, etc) */
+    usedInPriming: boolean;
+    /** flag representing if this import was statically picked up as part of the komaci document. we have to keep all statically analyzable imports */
+    staticallyAnalyzable: boolean;
+    /**
+     * component id for if this import maps to a component used in a template
+     * this is only managed as part of processTemplateImports
+     */
+    componentId?: string;
+};
+/**
+ * A type of import that extends the basic import metadata object to include a template komaci doc for an import.
+ */
+export declare type TemplateImportMetadata = BasicImportMetadata & {
+    templateKomaciDoc: KomaciDocument;
 };
+/**
+ * Main type for import meta data.
+ */
+export declare type ImportMetadata = BasicImportMetadata | TemplateImportMetadata;
+export declare type ImportIndexReference = Record<string, ImportMetadata>;
 /**
  * Map for all class properties and their basic, KomaciDoc analyzable metadata.
  *
@@ -190,4 +187,142 @@ export declare type ModuleContext = {
     astContext: AstContext;
     isExternal: boolean;
 };
+/** types of nodes */
+export declare enum FunctionTypes {
+    WIRE_FUNCTION = "WireFunction",
+    PRIMING_FUNCTION = "PrimingFunction",
+    GETTER_FUNCTION = "GetterFunction",
+    TEMPLATE_STRING = "TemplateStringFunction",
+    ERROR = "ErrorFunction"
+}
+/**
+ * Basic information needed by all function nodes
+ */
+export declare type BaseFunctionMetadata = {
+    type: FunctionTypes;
+    /** properties on the component this function requires to run */
+    requiredProperties: string[];
+};
+/**
+ * Details about an error that occured during resolvable module compilation
+ */
+export declare type ErrorFunctionMetadata = {
+    type: FunctionTypes.ERROR;
+    input: Value[];
+};
+/**
+ * Metadata for a wire function
+ */
+export declare type WireFunctionMetadata = BaseFunctionMetadata & {
+    type: FunctionTypes.WIRE_FUNCTION | FunctionTypes.PRIMING_FUNCTION;
+    input?: FunctionType['input'];
+    importReference: {
+        functionName: string;
+        batchingName?: string;
+        reducer?: string;
+    };
+};
+/**
+ * Metadata for a hoisted function type. Currently this is Getter functions and Template String Functions.
+ */
+export declare type HoistedFunctionMetadata = BaseFunctionMetadata & {
+    type: FunctionTypes.GETTER_FUNCTION | FunctionTypes.TEMPLATE_STRING;
+    /** ast node from the original component source */
+    componentAstNode?: NodePath<t.ClassProperty | t.ClassMethod>;
+    generatedName?: string;
+};
+/**
+ * Union of possible function types
+ */
+export declare type FunctionMetadata = HoistedFunctionMetadata | WireFunctionMetadata | ErrorFunctionMetadata;
+export declare type AdgMetadata = {
+    /** basic generated name for references from other adg. can be overriden if the adg is an export */
+    defaultGeneratedName: string;
+    /** factory functions used in the resolvable module when we build the adg. this is literally only ever ADG_FUNCTION or UNRESOLVED_FUNCTION */
+    requiredAdgFactoryFunctions: Set<IdKeys>;
+    requiredCompositionFactoryFunctions: Set<IdKeys>;
+    /** the name given to this adg when exported */
+    exportName?: string;
+    /** list of properties used by the associated template  */
+    propertiesUsedInTemplate: Set<string>;
+    /** compositions uplifted from template komaci document */
+    compositions?: KomaciDocument['compositions'];
+    /** properties consumable by this adg */
+    properties: Map<string, ClassPropertyContext>;
+    /** functions defined in this adg */
+    functions: FunctionMetadata[];
+    /** reference to the index in the adg array for the parent adg */
+    parentReference?: Adg['parentClass'];
+    /** to juggle weirdness with old getter support we can set this flag to avoid doing some extra processing on initial metadata collection */
+    hasSourceFile: boolean;
+};
+/**
+ * Complete structure of Metadata needed to compose a resolvable module
+ */
+export declare type ModuleMetadata = {
+    importGeneratorIndex: number;
+    adgGeneratorIndex: number;
+    importsByNamespace: ConsumedImports;
+    importsByName: Map<string, ImportMetadata>;
+    importIndexReference: Map<string, string>;
+    adgs: Map<number, AdgMetadata>;
+    exports: Record<string, AdgMetadata>;
+    templateKomaciDocMap: {
+        [fName: string]: KomaciDocument;
+    };
+};
+export declare type ImportBinding = {
+    importPath: string;
+    identifier: string;
+};
+export declare type PrimingAdapterDefinition = {
+    /**  Import metadata of the priming adapter */
+    prime: ImportBinding;
+    /** Contains metadata of the corresponding batch adapter */
+    batch?: {
+        prime: ImportBinding;
+        /** Metadata of the reducer that converts PrimingAdapter configuration to the corresponding single batch configuration */
+        reducer: ImportBinding;
+    };
+};
+/**
+ * Accepts importPath and identifier of a Wire Adapter
+ * Returns metadata of corresponding Priming Adapter or null if there is none
+ */
+export declare type GetPrimingAdapter = {
+    (importPath: string, identifier: string): PrimingAdapterDefinition | null;
+};
+export declare type WireAdaptersMapping = {
+    [importPath: string]: {
+        [identifier: string]: PrimingAdapterDefinition;
+    };
+};
+/**
+ * @typedef ValidGetterContext is an object that holds information about the member varaibles within a getter function.
+ * @property {NodePath<t.ClassMethod>} getter is the babel object for the getter method node.
+ * @property {Array<string>} memberUsage is an array of member variable names that are within the getter.
+ * @property {number} f_index is the index at which this getter was added to the functions array in the Komaci document.
+ */
+export declare type ValidGetterContext = {
+    getter: NodePath<t.ClassMethod>;
+    memberUsage: Array<string>;
+    generatedName: string;
+    f_index?: number;
+};
+/**
+ * @typedef ValidTemplateContext is an object that holds information about the member varaibles within a template.
+ * @property {NodePath<t.ClassProperty>} template is the babel object for the getter method node.
+ * @property {Array<string>} memberUsage is an array of member variable names that are within the template.
+ * @property {string} generatedName name used as function name in the resolvable module
+ * @property {number} f_index is the index at which this template was added to the functions array in the Komaci document.
+ */
+export declare type ValidTemplateContext = {
+    template: NodePath<t.ClassProperty>;
+    memberUsage: Array<string>;
+    generatedName: string;
+    f_index?: number;
+};
+export declare type Visited<T> = T & {
+    visited?: boolean;
+};
 //# sourceMappingURL=types.d.ts.map

package/build/types.js

@@ -1,6 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PropertyTypes = void 0;
+exports.FunctionTypes = exports.UNSUPPORTED_FUNCTION = exports.PropertyTypes = exports.IdKeys = exports.PROPS = exports.CONTEXT = exports.ERROR_PREFIX = void 0;
+exports.ERROR_PREFIX = '[komaci] ';
+exports.CONTEXT = 'ctx';
+exports.PROPS = 'props';
+var IdKeys;
+(function (IdKeys) {
+    IdKeys["CONTEXT"] = "CONTEXT";
+    IdKeys["PROPS"] = "PROPS";
+    IdKeys["FACTORY"] = "FACTORY";
+    IdKeys["COMPOSED_GRAPH_FUNC"] = "COMPOSED_GRAPH_FUNC";
+    IdKeys["ITERATION_FUNC"] = "ITERATION_FUNC";
+    IdKeys["UNRESOLVED_FUNC"] = "UNRESOLVED_FUNC";
+    IdKeys["SLOT_FUNC"] = "SLOT_FUNC";
+    IdKeys["ELEMENT_FUNC"] = "ELEMENT_FUNC";
+    IdKeys["ADG_FUNC"] = "ADG_FUNC";
+    IdKeys["SLOT"] = "SLOT";
+    IdKeys["COMPONENT_ID"] = "COMPONENT_ID";
+    IdKeys["UNDEFINED"] = "UNDEFINED";
+    IdKeys["PROP_API"] = "PROP_API";
+    IdKeys["PROP_INIT"] = "PROP_INIT";
+    IdKeys["PROP_FUNC"] = "PROP_FUNC";
+    IdKeys["PROP_GETTER"] = "PROP_GETTER";
+    IdKeys["DEFAULT_COMP"] = "DEFAULT_COMP";
+    IdKeys["FUNC_ID"] = "FUNC_ID";
+    IdKeys["FUNC_NAME"] = "FUNC_NAME";
+    IdKeys["FUNC_TYPE"] = "FUNC_TYPE";
+    IdKeys["FUNC_CONFIG"] = "FUNC_CONFIG";
+    IdKeys["FUNC_INPUT"] = "FUNC_INPUT";
+    IdKeys["WIRE_TYPE"] = "WIRE_TYPE";
+    IdKeys["UNRESOLVED_VALUE"] = "UNRESOLVED_VALUE";
+    IdKeys["BATCH_FUNC_ID"] = "BATCH_FUNC_ID";
+    IdKeys["BATCH_FUNC_NAME"] = "BATCH_FUNC_NAME";
+    IdKeys["REDUCER_FUNC_ID"] = "REDUCER_FUNC_ID";
+    IdKeys["IMG_SRC"] = "IMG_SRC";
+    IdKeys["IMG_FUNC"] = "IMG_FUNC";
+})(IdKeys = exports.IdKeys || (exports.IdKeys = {}));
 /**
  * Possbile types of properties we can encounter in a LWC
  */
@@ -8,9 +43,25 @@ var PropertyTypes;
 (function (PropertyTypes) {
     PropertyTypes["WIRE"] = "wire";
     PropertyTypes["GETTER"] = "getter";
-    PropertyTypes["INTERNAL"] = "internal";
-    PropertyTypes["PUBLIC"] = "api";
+    PropertyTypes["BASE"] = "base";
     PropertyTypes["IMPORT_REFERENCE"] = "importReference";
     PropertyTypes["TEMPLATE_STRING"] = "templateString";
 })(PropertyTypes = exports.PropertyTypes || (exports.PropertyTypes = {}));
+/**
+ * When a function is considered unsupported i.e.:
+ * - wire reference is not supported
+ * - getter or template string does not pass purity checks
+ *
+ * we set the f index for property metadata to -1
+ */
+exports.UNSUPPORTED_FUNCTION = -1;
+/** types of nodes */
+var FunctionTypes;
+(function (FunctionTypes) {
+    FunctionTypes["WIRE_FUNCTION"] = "WireFunction";
+    FunctionTypes["PRIMING_FUNCTION"] = "PrimingFunction";
+    FunctionTypes["GETTER_FUNCTION"] = "GetterFunction";
+    FunctionTypes["TEMPLATE_STRING"] = "TemplateStringFunction";
+    FunctionTypes["ERROR"] = "ErrorFunction";
+})(FunctionTypes = exports.FunctionTypes || (exports.FunctionTypes = {}));
 //# sourceMappingURL=types.js.map

package/build/utils.d.ts

@@ -1,9 +1,12 @@
 import * as t from '@babel/types';
 import { NodePath } from '@babel/core';
-import { AstContext, ClassPropertyContext, ClassPropertyContexts, ClassPropertyInfo, ClassPropertyNodes, ConsumedImports, ImplicitConsumption, ImportDeclarationInfo, ImportDeclarations, ModuleLevelConsumption } from './types';
+import { AstContext, ClassPropertyContext, ClassPropertyContexts, ClassPropertyNodes, ImplicitConsumption, ImportMetadata, ModuleMetadata, ValidGetterContext, ValidTemplateContext } from './types';
+import { Adg, FunctionType, KomaciDocument } from '@komaci/types';
 export declare const LIGHTNING_NS = "lightning";
 export declare const FORCE_NS = "force";
 export declare const ONE_NS = "one";
+export declare const GETTER_FUNCTION = "GetterFunction";
+export declare const TEMPLATED_STRING_FUNCTION = "TemplatedStringFunction";
 /**
  * collect node paths for different pieces of a given class so we can more effectively traverse them in the future
  *
@@ -12,21 +15,6 @@ export declare const ONE_NS = "one";
  * @param ast babel abstract syntax tree
  */
 export declare function getPropertyMetadataFromAst(ast: t.File): ClassPropertyNodes;
-/**
- * Given the AST of an entire JS source file, this method looks for class member properties.
- * If there is no default export in the AST, no class properties will be returned (empty array is returned).
- * @param astRoot AST representing an entire Program, as a @babel/types File object
- * @returns Array of NodePath<ClassProperty> representing the @babel NodePaths for all class member
- *          properties, if any exist. Otherwise, returns an empty array.
- */
-export declare function getClassProperties(astRoot: t.File): t.ClassProperty[];
-/**
- * Utility method that takes in an @babel/types ClassProperty array, and returns an array of ClassPropertyInfo
- * objects containing information about each ClassProperty from the input array.
- * @param classProperties
- * @returns Array of ClassPropertyInfo, where each element corresponds to the input ClassProperty array.
- */
-export declare function getClassPropertyInfos(classProperties?: Array<t.ClassProperty | t.ClassMethod>): ClassPropertyInfo[];
 /**
  * Given a valid functional node (tempalte string or getter function), collect information that we may not have been able to collect via KomaciDocument
  * and return a list of class member variables that are properly used in the method body.
@@ -41,8 +29,7 @@ export declare function getClassPropertyInfos(classProperties?: Array<t.ClassPro
  * @returns ImplicitConsumption, which contains an array representing the properly-used member variables.
  *          Returns ImplicitConsumption with an empty array if none were found.
  */
-export declare function implicitConsumptionMetadata(node: NodePath<t.ClassMethod | t.ClassProperty>, classPropInfos: ClassPropertyInfo[], importDeclarations: Map<string, ImportDeclarationInfo>, // import metadata
-moduleLevelConsumption: ModuleLevelConsumption): ImplicitConsumption;
+export declare function implicitConsumptionMetadata(node: NodePath<t.ClassMethod | t.ClassProperty>, adgIndex: number, moduleMetadata: ModuleMetadata): ImplicitConsumption;
 export declare function getMemberVarsFromGetter(path: NodePath<t.MemberExpression>, identifiers: Set<string>): void;
 /**
  * Collect metadata about all the imports consumed for an identifier in a getter
@@ -53,7 +40,7 @@ export declare function getMemberVarsFromGetter(path: NodePath<t.MemberExpressio
  * @param consumedImports The map to add info to about this identifier, whether it is an import that is being used
  *                        in the getter, or if it is assigned an import being used in the getter.
  */
-export declare function collectImportUsage(path: NodePath<t.Identifier>, classPropInfos: ClassPropertyInfo[], importDeclarations: ImportDeclarations, consumedImports: ConsumedImports): void;
+export declare function collectImportUsage(path: NodePath<t.Identifier>, moduleMetadata: ModuleMetadata, properties: ClassPropertyContexts): void;
 /**
  * Some children of nodes can be a direct identifier or a string literal. helper helps do
  * this consistant dance of getting the value from either
@@ -61,12 +48,6 @@ export declare function collectImportUsage(path: NodePath<t.Identifier>, classPr
  * @returns value
  */
 export declare function getFromIdentifierOrStringLiteral(node: t.Identifier | t.StringLiteral): string;
-/**
- * Function for getting an array of supported namesapce references.
- * @param astRoot the root of the ast
- * @returns an Array of supported namespace references.
- */
-export declare function getAllImportReferences(astRoot: t.File): Map<string, ImportDeclarationInfo>;
 /**
  * Function to get an array of function names that are defined at the module level.
  * @returns an array of function names that are defined at the module level.
@@ -149,5 +130,31 @@ export declare function isExpressionThisOrAlias(aliases: Set<string>, expr: t.Ex
  * @param declaredGetterVars a collection of variables declared within the getter
  * @param id the id of the member we are referencing.
  */
-export declare function isDeclaredInAst(astContext: AstContext, declaredGetterVars: string[], id: string): boolean;
+export declare function isDeclaredInAst(astContext: AstContext, importDeclarations: Map<string, ImportMetadata>, classProperties: ClassPropertyContexts, declaredGetterVars: string[], id: string): boolean;
+/**
+ * Function to update the Komaci Document with validated getter information. This function will update the functions array in the
+ * export default adg along with the property references in the property array.
+ * @param komaciScriptDoc the komaci document
+ * @param validGetterContext a collection
+ */
+export declare function updateKomaciDocumentWithValidGetters(komaciScriptDoc: KomaciDocument, validGetterContext: ValidGetterContext[]): void;
+/**
+ * Function to update the Komaci Document with validated template information. This function will update the functions array in the
+ * export default adg along with the property references in the property array.
+ * @param komaciScriptDoc the komaci document
+ * @param ValidTemplateContext details about the templates we've deemed to be valid
+ */
+export declare function updateKomaciDocumentWithValidTemplatedStrings(komaciScriptDoc: KomaciDocument, templateStrings: ValidTemplateContext[]): void;
+/**
+ * Update the functions array with the newly formed function reference and point the property to it
+ * @param adg The adg to update
+ * @param propertyName name of the property to update
+ */
+export declare function addPropertyFunction(adg: Adg, propertyName: string, func: FunctionType): number;
+/**
+ * Function to slpit an import path seperated by . EX: ./test.html = [, /test, html ]
+ * @param fullFilename the full file name
+ * @returns the full file name separated into segments.
+ */
+export declare function getFilepathSegments(fullFilename: string): string[];
 //# sourceMappingURL=utils.d.ts.map