@elyx-code/project-logic-tree 0.0.6464 → 0.0.6466

package/dist/index.d.ts

@@ -1870,6 +1870,17 @@ export declare function checkAreDefinitionEntitiesCompatibleAsDataType(sourceDef
 
 export declare function checkArePropertiesCompatibleAsDataType(sourceProperty: PropertyState, targetProperty: PropertyState): boolean;
 
+/**
+ * Recursively checks if all branches of a target entity come from the same caller
+ * This is useful to determine if the caller entity can be considered a single caller ancestor of the given target entity.
+ * @param {CallableEntityState} target The target entity to check
+ * @param {CallerEntityState} caller The caller entity to check against
+ * @returns {boolean} True if all branches of the target entity come from the same caller
+ **/
+export declare function checkEveryCallerComesFromCaller(target: CallableEntityState, caller: CallerEntityState): boolean;
+
+export declare function checkEveryCallerReachesOrIsAncestor(entity: CallableEntityState, ancestor: CallerEntityState): boolean;
+
 export declare function checkExtendsBaseEntity(entity: DefinitionEntityState | BuiltInBaseEntityState, baseEntityName: BaseEntityNames): boolean;
 
 export declare function checkHasBaseEntity(entity: DefinitionEntityState | BuiltInBaseEntityState, baseEntityName: BaseEntityNames): boolean;
@@ -1929,6 +1940,8 @@ export declare function checkIsRequiredValue(entity: EntityWithValueState | Prop
 
 export declare function checkParentEntryPointRequiresTermination(self: PassThroughCallableEntityState): boolean;
 
+export declare function checkReachesOrIsTarget(entity: ExecutableEntityState, target: CallableEntityState): 'success' | 'error' | 'entry' | 'loop-body' | 'same-entity' | null;
+
 export declare function checkScopeCompatibility(entityA: EntityState | Element_2 | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer, entityB: EntityState | Element_2 | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer, project: ProjectState): ScopeCompatibility;
 
 export declare function checkShouldInputOrOutputBePartOfFinalVariableObjectValue(entity: InputMapState | OutputMapState): boolean;
@@ -3986,13 +3999,20 @@ export declare enum ExtentionPriority {
     Low = 10
 }
 
+/**
+ * Remove any callers that are callers of other callers
+ * @param {CallerEntityState[]} callers
+ * @returns {CallerEntityState[]}
+ */
+export declare function filterOutDependentCallers(callers: CallerEntityState[]): CallerEntityState[];
+
 export declare function filterOutDuplicateEntities(entities: (EntityState | Element_2 | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget)[]): (Element_2 | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget | EntityState)[];
 
 export declare function filterOutDuplicateErrors(errors: (EntityGenerationError | EntityError)[]): EntityGenerationError[] | EntityError[];
 
 export declare function findEntityFromKeys(keys: string[], project: ProjectState): DefinitionEntityState | null;
 
-export declare function findNextIndividualCommonCallerAncestorFromGiven(entityA: ExecutableEntityState, entityB: ExecutableEntityState, from: CallerEntityState, ignoreCommonAncestorsFromDifferentCallTypes?: boolean): {
+export declare function findNextSingleCallerAncestor(target: CallableEntityState, from?: CallerEntityState): {
     ancestor: CallerEntityState | null;
     callType: 'success' | 'error' | 'entry' | 'loop-body' | null;
 };
@@ -4022,6 +4042,14 @@ export declare function flattenBuiltInBaseEntity(entity: IBuiltInBaseEntity | IB
     ignoreBuiltInBaseEntities?: boolean;
 }): (Element_2 | ElementTransfer | ElementShallowTransfer)[];
 
+/**
+ * Returns a flat list of caller entities that are ancestors in the call chain of the given entity
+ * Recursively checks until we have found the 'until' entity, as an ancestor or reached the root project entity
+ *
+ * @param {CallableEntityState} entity The entity to flatten the caller ancestors for
+ * @param {CallerEntityState} until The entity to stop flattening at
+ * @return {{ list: CallerEntityState[], last: CallerEntityState | null, callType: 'success' | 'error' | 'entry' | 'loop-body' | null }} An object containing the list of caller ancestors, the last found ancestor, and the call type
+ **/
 export declare function flattenCallerAncestorsUntil(entity: CallableEntityState, until: CallerEntityState): {
     list: CallerEntityState[];
     last: CallerEntityState | null;
@@ -5049,6 +5077,20 @@ export declare function getCallableEntityTypeSchema(): z_2.ZodUnion<[z_2.ZodUnio
 
 export declare function getCalledBy(entity: CallableEntityState | CallableEntity | CallableEntityTransfer | CallableEntityShallowTransfer): (CallerEntityState | CallerEntity | CallerEntityTransfer)[];
 
+/**
+ * In order to compile the call-chain of entities,
+ * often we need to check if the entity is called by parallel callers
+ * Meaning that it either has to be compiled after all of them,
+ * Or in the case of a condition caller, it cannot be compiled inside the block of either caller conditions
+
+ * @param {CallableEntityState} entity The entity to check for parallel callers
+ * @returns {{ ancestor: PassThroughCallableEntityState, callType: ('success'|'error') }[]} An array of independent parallel conditions direct calls
+ */
+export declare function getCalledByParallelCallers(entity: CallableEntityState): {
+    ancestor: PassThroughCallableEntityState;
+    callType: 'success' | 'error';
+}[];
+
 export declare function getCallerEntityReferenceSchema(): z_2.ZodUnion<[z_2.ZodUnion<[z_2.ZodObject<{
     id: z_2.ZodString;
     type: z_2.ZodLiteral<import("../../..").EntityType.GenericReference>;
@@ -6598,24 +6640,11 @@ export declare function getDraggablePlayableEntityTypeSchema(): z_2.ZodUnion<[z_
     type: import("../../..").EntityType.GlobalEvent;
 }>, z_2.ZodRecord<z_2.ZodString, z_2.ZodAny>]>]>]>;
 
-export declare function getEarliestCommonAncestorOfAllCallers(entity: CallableEntityState, ignoreEarlierChainedCallers?: boolean): {
-    ancestor: CallerEntityState;
-    callType: 'success' | 'error' | 'entry' | 'loop-body';
-} | {
-    ancestor: null;
-    callType: null;
-};
-
 export declare function getEarliestCommonCallerAncestor(entityA: ExecutableEntityState, entityB: ExecutableEntityState, ignoreCommonAncestorsFromDifferentCallTypes?: boolean): {
     ancestor: CallerEntityState | null;
     callType: 'success' | 'error' | 'entry' | 'loop-body' | 'same-entity' | null;
 };
 
-export declare function getEarliestIndividualCommonCallerAncestor(entityA: ExecutableEntityState, entityB: ExecutableEntityState, ignoreCommonAncestorsFromDifferentCallTypes?: boolean): {
-    ancestor: CallerEntityState | null;
-    callType: 'success' | 'error' | 'entry' | 'loop-body' | 'same-entity' | null;
-};
-
 export declare function getEarliestSingleCallerAncestorOfValueWriterAndItsValueReaders(entity: VariableDeclarationState | OutputMapState): {
     ancestor: CallerEntityState | null;
     callType: 'success' | 'error' | 'entry' | 'loop-body' | null;
@@ -7873,6 +7902,15 @@ export declare function getOnlyRelevantErrorsForPublication(project: ProjectStat
 
 declare function getOrderByClauseFromSelectStatement(selectStatement: SelectStmt): OrderByClause | null;
 
+/**
+ * Recursively finds the parent callable entity of the given entity.
+ * If the entity is a condition, it will traverse up to find the first callable entity.
+ * If the entity is already a callable entity, it will return itself.
+ * If no callable entity is found, it returns null.
+
+ * @param {EntityState} entity The entity to start searching from.
+ * @returns {CallableEntityState | null} The parent callable entity or null if not found.
+ **/
 export declare function getParentCallableEntity(entity: EntityState): CallableEntityState | null;
 
 export declare function getParentCallerEntity(entity: EntityState): CallerEntityState | null;
@@ -7891,6 +7929,13 @@ export declare function getParentCanvasEntityFromTransfer(entity: Element_2 | El
  */
 export declare function getParentEntryPoint(entity: EntityState): EntryPointEntityState | null;
 
+/**
+ * Finds the parent executable entity for a given entity.
+ * It traverses up the entity hierarchy until it finds an entity of type ExecutableEntityState
+ * or returns null if no such entity is found.
+ * @param {EntityState} entity EntityState to find the parent executable entity for
+ * @returns {ExecutableEntityState | null}
+ */
 export declare function getParentExecutableEntity(entity: EntityState): ExecutableEntityState | null;
 
 export declare function getParentPassthroughCallableEntity(entity: EntityState): PassThroughCallableEntityState | null;
@@ -14405,6 +14450,20 @@ export declare function removeDisabledReasons(existingDisbledResons: CanvasEntit
 
 export declare function resolveActionDescriptorName(actionDescriptor: ActionDescriptorState): string;
 
+/**
+ * Recursively resolves all condition entities which need to be passed
+ * to get from the entry point to the given entity.
+ * It aggregates all conditions of ancestors into a final array
+
+ * @param {CallableEntityState} entity The entity to resolve conditions for
+ * @returns {{ ancestor: ConditionState, call: CallableEntityState, callType: ('success'|'error') }[]} An array of independent parallel conditions direct calls
+ */
+export declare function resolveAllParallelAncestorConditionCallersForEntity(entity: CallableEntityState): {
+    condition: ConditionState;
+    call: CallableEntityState;
+    callType: 'success' | 'error';
+}[];
+
 declare function resolveAreThereConflictingColumnsInSelectAll(allColumnsSelector: AllColumnsSelector | null): boolean;
 
 export declare function resolveArgumentDeclarationValue(entity: ArgumentDeclarationState, context: IValueResolutionContext): IDynamicValue | null;