@elyx-code/project-logic-tree 0.0.6996 → 0.0.7000

package/dist/tree/utils/index.d.ts

@@ -0,0 +1,543 @@
+import { BaseEntityNames, ElementGenerationTarget, ElementShallowTransfer, ElementTransfer, EntityType, Element, IGenericReference, EntityId, ValueReadingEntity, DraggableElement, CallableEntity, CallableEntityTransfer, CallerEntity, CallerEntityTransfer, DraggableElementTransfer, ValueReadingEntityTransfer, CallableEntityShallowTransfer, DraggableElementShallowTransfer, EntityVersion, UserManagedElementTransfer, UserManagedElement, UserManagedElementShallowTransfer } from '../../definitions';
+import { DraggableCallableEntityState, CanvasEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, DraggableExecutableEntityState, DraggablePassThroughCallableEntityState, ValueReadingEntityState, ValueWritingEntityState, EntityWithValueState, VariableState, BuiltInBaseEntityState, TerminationEntityState, ExecutableEntityState, ValueDescriptorState, CallableEntityState, CallerEntityState, PassThroughCallableEntityState, PrimitiveEntityState, InternalCallState, ActionDescriptorState, UserManagedEntityState, PassThroughCallableEntityWithOutputsState } from '../state';
+import { IChangeSet, IRecordChangeSet, ChangeSet } from '../state/change-set/change-set';
+import { FunctionCallState } from '../state/function-call';
+import { InputMapState } from '../state/input-map';
+import { VariableDeclarationState } from '../state/variable-declaration';
+import { ArgumentDeclarationState } from '../state/argument-declaration';
+import { OutputMapState } from '../state/output-map';
+import { ConditionState } from '../state/condition';
+import { FunctionDeclarationState } from '../state/function-declaration';
+import { ProjectState } from '../state/project/project';
+import { PropertyState } from '../state/property';
+import { OperationState } from '../state/operation';
+import { DefinitionEntityState } from '../state/definition-entity';
+import { VariableInstanceState } from '../state/variable-instance';
+import { LoopState } from '../state/loop';
+import { SearchState } from '../state/search';
+import { EntityStateConstructor } from '../state/types/constructors';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export * from './literal-value';
+export * from './flatten';
+export * from './data-type';
+export * from './traverser';
+export * from './names';
+export * from './references';
+export * from './uuid';
+export * from './variables';
+export * from './shared-data-structure-entity';
+export * from './string';
+export * from './values-validations';
+export * from './sql-migrations';
+export * from './log';
+export * from './validation-utils';
+export declare function flattenCanvasAncestorsUntil(entity: CanvasEntityState, until: CanvasEntityState): {
+    list: CanvasEntityState[];
+    last: CanvasEntityState | null;
+};
+/**
+ * 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;
+    callType: 'success' | 'error' | 'entry' | 'loop-body' | null;
+};
+export declare function checkReachesOrIsTarget(entity: ExecutableEntityState, target: CallableEntityState): 'success' | 'error' | 'entry' | 'loop-body' | 'same-entity' | null;
+/**
+ * Most entities will be part of a logic chain that starts at an entry point entity
+ * We we need to find the entry point entity that is the parent of the given entity
+ * @param entity The entity to find the entry point for
+ * @returns The entry point entity if found, or null if not found
+ */
+export declare function getParentEntryPoint(entity: EntityState): EntryPointEntityState | null;
+export declare function checkEveryCallerReachesOrIsAncestor(entity: CallableEntityState, ancestor: CallerEntityState): boolean;
+/**
+ * Remove any callers that are callers of other callers
+ * @param {CallerEntityState[]} callers
+ * @returns {CallerEntityState[]}
+ */
+export declare function filterOutDependentCallers(callers: CallerEntityState[]): CallerEntityState[];
+export declare function flattenCallers(entity: CallableEntityState): CallerEntityState[];
+export declare function flattenCallersWithCallType(entity: CallableEntityState): {
+    caller: CallerEntityState;
+    callType: 'success' | 'error' | 'entry' | 'loop-body';
+}[];
+export declare function resolveEarliestSingleCallerAncestor(entity: CallableEntityState): {
+    ancestor: CallerEntityState | null;
+    callType: 'success' | 'error' | 'entry' | 'loop-body' | null;
+};
+export declare function findNextCombinedSingleCallerAncestor(targetA: CallableEntityState | CallerEntityState, targetB: CallableEntityState | CallerEntityState, from?: CallerEntityState): {
+    ancestor: CallerEntityState | null;
+    callType: 'success' | 'error' | 'entry' | 'loop-body' | null;
+};
+export declare function findNextSingleCallerAncestor(target: CallableEntityState | EntryPointEntityState, from?: CallerEntityState, debug?: boolean): {
+    ancestor: CallerEntityState | null;
+    callType: 'success' | 'error' | 'entry' | 'loop-body' | null;
+};
+export declare function getEarliestSingleCallerAncestorOfValueWriterAndItsValueReaders(entity: PassThroughCallableEntityWithOutputsState | OutputMapState): {
+    ancestor: CallerEntityState | null;
+    callType: 'success' | 'error' | 'entry' | 'loop-body' | null;
+};
+/**
+ * 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;
+/**
+ * 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';
+}[];
+/**
+ * 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';
+}[];
+/**
+ * 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 flattenWrites(entity: ValueWritingEntityState, seenEntities?: Set<string>): ValueReadingEntityState[];
+export declare function calculateNewParentBasedOnCallers(self: CallableEntityState): EntityWithLogicScopeState | ProjectState;
+export declare function applyNewScope(self: CallableEntityState, changeSet: ChangeSet | null): void;
+export declare function getCommonChildren(entityA: CanvasEntityState, entityB: CanvasEntityState, seenEntities?: Set<EntityId>): CanvasEntityState[];
+export declare function checkIsBranchDependentButNotDirectlyOnBranch(branchA: CanvasEntityState, branchB: CanvasEntityState): boolean;
+export declare function checkIsBranchDependentOnBranch(descendant: CanvasEntityState, ancestor: CanvasEntityState): boolean;
+export declare function checkIsCallerBranchDependentOnBranch(descendant: CallableEntityState, ancestor: CallerEntityState): boolean;
+export declare function getCommonAncestor(entityA: EntityState, entityB: EntityState): EntityState | 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 getParentCanvasEntity(entity: EntityState): CanvasEntityState | null;
+export declare function getParentCanvasEntityFromTransfer(entity: Element | ElementTransfer | ElementShallowTransfer | IGenericReference, allKnownEntities: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>): DraggableElement | DraggableElementTransfer | DraggableElementShallowTransfer | null;
+export declare function flattenElementCallsWithCallType(element: CallerEntityState, options?: {
+    excludeLoopBodies?: boolean;
+}): {
+    callee: CallableEntityState;
+    callType: 'success' | 'error' | 'entry' | 'loop-body';
+}[];
+/**
+ * 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 getParentPassthroughCallableEntity(entity: EntityState): PassThroughCallableEntityState | null;
+export declare function getParentCallerEntity(entity: EntityState): CallerEntityState | null;
+export declare function getChildrenEntityWithValues(entity: CanvasEntityState | InternalCallState): EntityWithValueState[];
+export declare function sortChildrenEntitiesBasedOnExecutionDependencies(entity: CanvasEntityState): CanvasEntityState[];
+export declare function sortCallsBasedOnExecutionDependencies(calls: DraggableCallableEntityState[]): DraggableCallableEntityState[];
+export declare function groupCallsBasedOnParallelizableExecution(calls: DraggableCallableEntityState[]): DraggableCallableEntityState[][];
+export declare function getParentCanvasEntities(entities: EntityState[]): CanvasEntityState[];
+export declare function getCalls(entity: DraggableExecutableEntityState): DraggableCallableEntityState[];
+export declare function resolveFirstCallsSecond(first: DraggableExecutableEntityState, second: DraggableCallableEntityState): boolean;
+export declare function getWrites(entity: ValueWritingEntityState): ValueReadingEntityState[];
+export declare function resolveFirstWritesSecond(first: ValueWritingEntityState, second: ValueReadingEntityState): boolean;
+export declare function getVariableFromInputMapping(input: InputMapState): VariableState | null;
+export declare function getLinkedEntitiesFromArgumentDeclaration(argumentDeclaration: ArgumentDeclarationState): ValueReadingEntityState[];
+export declare function getVariablesFromInputMaps(args?: InputMapState[]): VariableState[];
+export declare function getVariablesFromArgumentDeclarations(args?: ArgumentDeclarationState[]): VariableState[];
+export declare function getVariablesFromReturnDeclarations(returnDecls?: InputMapState[]): VariableState[];
+export declare function getVariableFromReturnVariablePointer(entity: VariableState | InputMapState): VariableState | null;
+export declare function getVariablesFromOutputMapping(returnedElement: OutputMapState): VariableState[];
+export declare function getVariablesFromOutputMaps(returnedElements?: OutputMapState[]): VariableState[];
+/**
+ * Recursively flattens all callable entities called by the given caller entity.
+ * It doesn't include itself
+ *
+ * @param {CallerEntityState} element
+ * @returns {CallableEntityState[]} Not including self
+ */
+export declare function flattenElementCalls(element: CallerEntityState, options?: {
+    sorting?: 'local-y-axis';
+    excludeLoopBodies?: boolean;
+}): CallableEntityState[];
+export declare function flattenElementCallsAsync(element: CallerEntityState, options?: YieldOptions & {
+    sorting?: 'local-y-axis';
+    excludeLoopBodies?: boolean;
+}): Promise<CallableEntityState[]>;
+export declare function flattenElementCallsOnTheSameScope(element: CallerEntityState): CallableEntityState[];
+export declare function flattenVariableWrites(variable: VariableState, seenVariables?: Set<string>): VariableState[];
+export declare function flattenVariableReads(variable: VariableState, seenVariables?: Set<string>): VariableState[];
+export declare function flattenVariables(element: CanvasEntityState, seenVariables?: Set<string>): VariableState[];
+/**
+ * Given an entity from the canvas, it returns a flat list of entities
+ * representing the chain of entities on the right of the given one, that are related to it
+ * Including relations of its relations, recursively
+ *
+ * @param entity The entity to flatten
+ * @param seenEntities A set of already seen entities to avoid infinite loops
+ * @returns {CanvasEntityState[]} A flat list of derived canvas entities
+ */
+export declare function flattenDerivedCanvasEntities(entity: CanvasEntityState, seenEntities?: Set<EntityId>): CanvasEntityState[];
+export declare function flattenCalls(entities: CallableEntityState[], options?: {
+    sorting?: 'local-y-axis';
+    excludeLoopBodies?: boolean;
+}): CallableEntityState[];
+export declare function flattenCallsAsync(entities: CallableEntityState[], options?: YieldOptions & {
+    sorting?: 'local-y-axis';
+    excludeLoopBodies?: boolean;
+}): Promise<CallableEntityState[]>;
+export declare function flattenProjectElements(project: ProjectState): EntityState[];
+export declare function findReferenceToSelfInList(element: EntityState, elements: EntityState[]): EntityState[];
+export declare function findReferencesToSelfInProject(element: EntityState): EntityState[];
+export declare function enrichFromKnownEntities(entity: ElementTransfer | Element | ElementShallowTransfer | IGenericReference | EntityId, allKnownEntities: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>): Element | ElementTransfer | ElementShallowTransfer | null;
+/**
+ * Maps the keys of a record using a provided map of entity IDs.
+ *
+ * @param {Record< EntityId, Element | ElementTransfer | ElementShallowTransfer>} record - The record to be mapped.
+ * @param {Map<EntityId, EntityId>} entityIdMaps - A map containing the entity ID mappings.
+ * @returns
+ */
+export declare function mapRecord(record: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer> | undefined, entityIdMaps: Map<EntityId, EntityId>): Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>;
+/**
+ * Given an entity, it returns a record of entity ids and their version ids
+ * Both upstream and downstream references
+ *
+ * @param {ElementTransfer | Element | ElementShallowTransfer | EntityState} entity
+ * @param {Record< EntityId, Element | ElementTransfer | ElementShallowTransfer>} allKnownEntities
+ * @param {{ ignoreBuiltInBaseEntities?: boolean; allBuiltInEntityIds?: EntityId[]; entityMaps?: Map<string, string>; }} options
+ * @returns {upstream: Record<EntityId, EntityVersion>; downstream: Record<EntityId, EntityVersion>}
+ */
+export declare function getReferencedIds(entity: ElementTransfer | Element | ElementShallowTransfer | EntityState, allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allBuiltInEntityIds?: Set<EntityId>;
+    entityMaps?: Map<string, string>;
+    debug?: boolean;
+}): {
+    upstream: Record<EntityId, EntityVersion>;
+    downstream: Record<EntityId, EntityVersion>;
+};
+/**
+ * In the draggable canvas, entities are groups as nodes.
+ * Some entity types represent the top nodes, and the rest are nested within them.
+ * With the exception of built-in entities, all entities can be traced up the tree to a top-level draggable node.
+ * This function takes a node entity and flattens it and all its nested entities into a record of entities by their IDs.
+ *
+ * @param entity
+ * @param allKnownEntities
+ * @param seenEntities
+ * @param options
+ * @returns {Record<EntityId, UserManagedElementTransfer | UserManagedElement | UserManagedElementShallowTransfer | UserManagedEntityState>}
+ */
+export declare function flattenNodeAsRecord(entity: DraggableElementTransfer | DraggableElement | DraggableElementShallowTransfer | CanvasEntityState, allKnownEntities: Record<EntityId, ElementTransfer | Element | ElementShallowTransfer | EntityState> | {
+    [EntityId: EntityId]: Element | ElementTransfer | ElementShallowTransfer | EntityState;
+}, seenEntities?: Set<EntityId>, options?: {
+    ignoreBuiltInBaseEntities?: boolean;
+    allBuiltInEntityIds?: Set<EntityId>;
+    entityMaps?: Map<string, string>;
+    debug?: boolean;
+}): Record<EntityId, UserManagedElementTransfer | UserManagedElement | UserManagedElementShallowTransfer | UserManagedEntityState>;
+export declare function getRelatedCanvasElementsOnTheLeftFromTransfer(entity: DraggableElement | DraggableElementTransfer | DraggableElementShallowTransfer, allKnownEntities: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer>): (DraggableElement | DraggableElementTransfer | DraggableElementShallowTransfer)[];
+export declare function getRelatedCanvasElementsOnTheLeft(entity: CanvasEntityState): CanvasEntityState[];
+export declare function flattenRelatedCanvasElementsOnTheLeft(entity: CanvasEntityState): CanvasEntityState[];
+export declare function getRelatedCanvasElementsOnTheLeftAsync(entity: CanvasEntityState, options?: YieldOptions): Promise<CanvasEntityState[]>;
+export declare function flattenRelatedCanvasElementsOnTheLeftAsync(entity: CanvasEntityState, options?: YieldOptions): Promise<CanvasEntityState[]>;
+export declare function getCalledBy(entity: CallableEntityState | CallableEntity | CallableEntityTransfer | CallableEntityShallowTransfer): (CallerEntityState | CallerEntity | CallerEntityTransfer)[];
+export declare function getEntityArgumentDeclarations(entity: ExecutableEntityState): (ArgumentDeclarationState | ValueDescriptorState)[];
+export declare function getUsedArgFromDeclaration(argumentDeclaration: ArgumentDeclarationState, entity: ConditionState | FunctionCallState | OperationState): InputMapState | null;
+export declare function getEntityInputMaps(entity: DraggablePassThroughCallableEntityState): InputMapState[];
+export declare function getEntityReturnDeclarations(entity: TerminationEntityState | FunctionCallState | OperationState | SearchState): (PropertyState | ValueDescriptorState)[];
+export declare function getUsedReturnFromDeclaration(returnDeclaration: InputMapState, entity: ConditionState | FunctionCallState | OperationState): OutputMapState | null;
+export declare function getEntityOutputMaps(entity: DraggablePassThroughCallableEntityState): OutputMapState[];
+export declare function getCanvasEntityDerivedFromValueReadingEntity(valueReadingEntity: ValueReadingEntityState): CanvasEntityState | null;
+export declare function getCanvasEntityDerivedFromValueReadingEntityFromTransfer(valueReadingEntity: ValueReadingEntity | ValueReadingEntityTransfer, allKnownEntities: Record<EntityId, ElementTransfer | ElementShallowTransfer>): DraggableElement | DraggableElementTransfer | DraggableElementShallowTransfer | null;
+/**
+ * Given an entity from the canvas, it returns a flat list of entities
+ * representing the chain of entities on the right of the given one, that are related to it
+ * Including relations of its relations, recursively
+ *
+ * @param entity The entity to flatten
+ * @param seenEntities A set of already seen entities to avoid infinite loops
+ * @returns {CanvasEntityState[]} A flat list of derived canvas entities
+ */
+/**
+ * Given an entity from the canvas, it returns a flat list of entities
+ * representing the chain of entities on the right of the given one, that are related to it
+ * Including relations of its relations, recursively
+ *
+ * @param entity The entity to flatten
+ * @param seenEntities A set of already seen entities to avoid infinite loops
+ * @returns {CanvasEntityState[]} A flat list of derived canvas entities
+ */
+export declare function flattenDerivedCanvasEntitiesAsync(entity: CanvasEntityState, seenEntities?: Set<EntityId>, options?: YieldOptions): Promise<CanvasEntityState[]>;
+export declare function getCanvasEntitiesDerivedFromInternalCalls(entity: VariableState): CanvasEntityState[];
+export declare function getCallableEntitiesDerivedFromInternalCalls(entity: VariableState): CallableEntityState[];
+export declare function getCanvasEntitiesDerivedFromWrites(valueWritingEntity: ValueWritingEntityState): CanvasEntityState[];
+export declare function getCallableEntitiesDerivedFromWrites(valueWritingEntity: ValueWritingEntityState): CallableEntityState[];
+export declare function filterOutDuplicateEntitiesAsync(entities: (EntityState | Element | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget)[], options?: YieldOptions): Promise<(Element | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget | EntityState)[]>;
+export declare function filterOutDuplicateEntities(entities: (EntityState | Element | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget)[]): (Element | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget | EntityState)[];
+export declare function getFirstParentExecutableEntity(entity: EntityState): ExecutableEntityState | null;
+/**
+ * Get all the entities that are related to the given entity on the right
+ * This includes:
+ *	- entities called by the given entity
+ *	- entities that read from the given entity,
+ *		both variables and other canvas entities that are the parent of the value reading entity
+ */
+export declare function getRelatedCanvasElementsOnTheRight(entity: CanvasEntityState | ProjectState | InternalCallState, respectCollapse?: boolean): CanvasEntityState[];
+export declare function getRelatedCallableElementsOnTheRight(entity: CanvasEntityState | ProjectState | InternalCallState, respectCollapse?: boolean): CallableEntityState[];
+export declare function flattenRelatedCanvasElementsOnTheRight(entity: CanvasEntityState | ProjectState | InternalCallState, respectCollapse?: boolean): CanvasEntityState[];
+export declare function flattenRelatedCallableElementsOnTheRight(entity: CanvasEntityState | ProjectState | InternalCallState, respectCollapse?: boolean): CallableEntityState[];
+/**
+ * Get all the entities that are related to the given entity on the right
+ * This includes:
+ * - entities called by the given entity
+ * - entities that read from the given entity,
+ * both variables and other canvas entities that are the parent of the value reading entity
+ */
+export declare function getRelatedCanvasElementsOnTheRightAsync(entity: CanvasEntityState | ProjectState | InternalCallState, respectCollapse?: boolean, options?: YieldOptions): Promise<CanvasEntityState[]>;
+export declare function getRelatedCallableElementsOnTheRightAsync(entity: CanvasEntityState | ProjectState | InternalCallState, respectCollapse?: boolean, options?: YieldOptions): Promise<CallableEntityState[]>;
+export declare function flattenRelatedCanvasElementsOnTheRightAsync(entity: CanvasEntityState | ProjectState | InternalCallState, respectCollapse?: boolean, options?: YieldOptions): Promise<CanvasEntityState[]>;
+export declare function flattenRelatedCallableElementsOnTheRightAsync(entity: CanvasEntityState | ProjectState | InternalCallState, respectCollapse?: boolean, options?: YieldOptions): Promise<CallableEntityState[]>;
+export declare function flattenDefinitionEntityImplementionTypes(entity: DefinitionEntityState): (BaseEntityNames | EntityType.DefinitionEntity)[];
+export declare function flattenDefinitionEntityExtensionTypes(entity: DefinitionEntityState | BuiltInBaseEntityState): (BaseEntityNames | EntityType.DefinitionEntity)[];
+export declare function flattenDefinitionEntityExtensions(entity: DefinitionEntityState | BuiltInBaseEntityState): (BuiltInBaseEntityState | DefinitionEntityState)[];
+export declare function flattenDefinitionEntityImplementations(entity: DefinitionEntityState): (BuiltInBaseEntityState | DefinitionEntityState)[];
+export declare function flattenDefinitionEntityExtensionAndImplementations(entity: DefinitionEntityState): (BuiltInBaseEntityState | DefinitionEntityState)[];
+export declare function flattenDefinitionEntityExtensionAndImplementationTypes(entity: DefinitionEntityState): (BaseEntityNames | EntityType.DefinitionEntity)[];
+export declare function checkHasBaseEntity(entity: DefinitionEntityState | BuiltInBaseEntityState, baseEntityName: BaseEntityNames): boolean;
+export declare function getFirstBaseEntityWithOwnBase(entity: DefinitionEntityState | BuiltInBaseEntityState, baseEntityName: BaseEntityNames): BuiltInBaseEntityState | null;
+export declare function getBaseEntity(entity: DefinitionEntityState | BuiltInBaseEntityState, baseEntityName: BaseEntityNames): BuiltInBaseEntityState | null;
+export declare function getLowestPersistedEntityImplementation(entity: DefinitionEntityState): DefinitionEntityState | null;
+export declare function getExtendedBuiltInEntity(entity: DefinitionEntityState): BuiltInBaseEntityState | null;
+export declare function getImplementedBuiltInEntity(entity: DefinitionEntityState): BuiltInBaseEntityState | null;
+export declare function getExtendedDefinitionEntity(entity: DefinitionEntityState): DefinitionEntityState | null;
+export declare function getBaseBuiltInEntities(entity: DefinitionEntityState | BuiltInBaseEntityState): BuiltInBaseEntityState[];
+export declare function getIsInteractive(entity: DefinitionEntityState | BuiltInBaseEntityState | PrimitiveEntityState | PropertyState | InputMapState | OutputMapState): boolean;
+/**
+ * If the given entity is one of type: DefinitionEntity, BuiltInBaseEntity, PrimitiveEntity, Property, InputMap, OutputMap
+ * Returns true if it is interactive
+ *
+ * Otherwise, for all other entity types, returns true
+ *
+ * @param {EntityState} entity
+ * @returns boolean
+ */
+export declare function getIsInteractiveOrTrue(entity: EntityState): boolean;
+export declare function checkIsGlobalVariable(entity: VariableDeclarationState): boolean;
+export declare function checkIsGloballyDeclared(entity: ConditionState | FunctionCallState | OperationState | VariableDeclarationState | VariableInstanceState | FunctionCallState | LoopState | SearchState): boolean;
+export declare function checkIsDetachedBranch(entity: CanvasEntityState): boolean;
+export declare function checkIsDetachedBranchShallow(entity: CanvasEntityState): boolean;
+export declare function getHeadIfPartOfDetachedBranch(entity: CanvasEntityState, levelsChecked?: number): CanvasEntityState | null;
+export declare function flattenDetachedBranch(entity: CanvasEntityState): CanvasEntityState[];
+export declare function checkIsMethod(entity: EntityState): boolean;
+export declare function mergeListOfEntities(oldErrors: EntityState[], newErrors: EntityState[]): EntityState[];
+export declare function getPrototypeByType(type: EntityType): EntityStateConstructor | null;
+/**
+ * Recursively access 'parent' property until we find the first parent entity that can own scope, or the project
+ * @param entity EntityState or Element that has a 'parent' property
+ * @param project ProjectState to check against
+ * @param _initialEntity Initial entity to check against, used for recursion
+ * @returns EntityWithLogicScopeState or ProjectState that owns the scope, or null if no valid scope owner is found
+ */
+export declare function getScopeOwner(entity: EntityState | Element | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer, project: ProjectState, _initialEntity?: EntityState | Element | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer | null): EntityWithLogicScopeState | ProjectState | null;
+export declare function getFirstNonLoopScopeOwner(entity: EntityState | Element | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer, project: ProjectState, _initialEntity?: EntityState | Element | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer | null): EntryPointEntityState | ProjectState | null;
+/**
+ * Returns the root entry point entity that owns the scope of the given entity
+ *
+ * @param {EntityState | Element | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer} entity EntityState or Element that has a 'parent' property
+ * @returns {EntityWithLogicScopeState | null} EntityWithLogicScopeState that owns the root entry point scope, or null if no valid scope owner is found
+ */
+export declare function getRootEntryPointScopeOwner(entity: EntityState | Element | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer, project: ProjectState): EntityWithLogicScopeState | null;
+export declare function checkIsNestedScope(parent: EntityWithLogicScopeState | ProjectState, child: EntityWithLogicScopeState | ProjectState, project: ProjectState): boolean;
+export declare enum ScopeCompatibilityType {
+    SameBothLocal = "same-both-local",
+    AInB = "a-in-b",
+    BInA = "b-in-a",
+    ParallelInCommonParent = "parallel-in-common-parent",
+    ParallelInProject = "parallel-in-project",
+    AIsGlobalBIsNot = "a-is-global-b-is-not",
+    BIsGlobalAIsNot = "b-is-global-a-is-not",
+    SameBothGlobal = "same-both-global"
+}
+export interface IScopeCompatibility {
+    compatible: boolean;
+    type: ScopeCompatibilityType;
+    commonAncestorScope: EntityWithLogicScopeState | ProjectState;
+}
+export interface ICompatibleSameBothLocalScope extends IScopeCompatibility {
+    compatible: true;
+    type: ScopeCompatibilityType.SameBothLocal;
+}
+export interface ICompatibleSameBothGlobalScope extends IScopeCompatibility {
+    compatible: true;
+    type: ScopeCompatibilityType.SameBothGlobal;
+}
+export interface ICompatibleAInBScope extends IScopeCompatibility {
+    compatible: true;
+    type: ScopeCompatibilityType.AInB;
+}
+export interface ICompatibleBInAScope extends IScopeCompatibility {
+    compatible: true;
+    type: ScopeCompatibilityType.BInA;
+}
+export interface IIncompatibleParallelInProjectScope extends IScopeCompatibility {
+    compatible: false;
+    type: ScopeCompatibilityType.ParallelInProject;
+}
+export interface IIncompatibleParallelInCommonParentScope extends IScopeCompatibility {
+    compatible: false;
+    type: ScopeCompatibilityType.ParallelInCommonParent;
+}
+export interface IIncompatibleAIsGlobalBIsNotScope extends IScopeCompatibility {
+    compatible: false;
+    type: ScopeCompatibilityType.AIsGlobalBIsNot;
+}
+export interface IIncompatibleBIsGlobalAIsNotScope extends IScopeCompatibility {
+    compatible: false;
+    type: ScopeCompatibilityType.BIsGlobalAIsNot;
+}
+export type ScopeCompatibility = ICompatibleSameBothLocalScope | ICompatibleSameBothGlobalScope | ICompatibleAInBScope | ICompatibleBInAScope | IIncompatibleParallelInProjectScope | IIncompatibleParallelInCommonParentScope | IIncompatibleAIsGlobalBIsNotScope | IIncompatibleBIsGlobalAIsNotScope;
+export type CompatibleScope = ICompatibleSameBothLocalScope | ICompatibleSameBothGlobalScope | ICompatibleAInBScope | ICompatibleBInAScope;
+export type IncompatibleScope = IIncompatibleParallelInProjectScope | IIncompatibleParallelInCommonParentScope | IIncompatibleAIsGlobalBIsNotScope | IIncompatibleBIsGlobalAIsNotScope;
+export declare function checkScopeCompatibility(entityA: EntityState | Element | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer, entityB: EntityState | Element | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer, project: ProjectState): ScopeCompatibility;
+export declare function getHighestScope(scopeOwnerA: EntityWithLogicScopeState, scopeOwnerB: EntityWithLogicScopeState, project: ProjectState): EntityWithLogicScopeState | null;
+export declare function getDeepestScope(scopeOwners: EntityWithLogicScopeState[]): EntityWithLogicScopeState | null;
+export declare function toEntityState(entity: string | EntityState | IGenericReference | Element | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget, project: ProjectState): EntityState | null;
+export declare function getBuiltInEntityOwner(entity: EntityState): EntityState | null;
+export declare function checkIsCallableEntityReachable(entity: CallableEntityState): {
+    reachable: boolean;
+    entryPoint: EntryPointEntityState | null;
+    blocks: {
+        blockedByCaller: CallerEntityState;
+        blockedByCalling: TerminationEntityState;
+    }[];
+};
+export declare function checkIsCanvasEntity(entity: EntityState): boolean;
+export declare function mapActionDescriptorToTypeItRepresents(entity: EntityState): EntityType;
+export declare function getBodyDescriptorForLoopDescriptor(loopDescriptor: ActionDescriptorState): ActionDescriptorState;
+export declare function checkExtendsBaseEntity(entity: DefinitionEntityState | BuiltInBaseEntityState, baseEntityName: BaseEntityNames): boolean;
+export declare function checkImplementsBaseEntity(entity: DefinitionEntityState | BuiltInBaseEntityState, baseEntityName: BaseEntityNames): boolean;
+export declare function getPeristedEntities(project: ProjectState): DefinitionEntityState[];
+export declare function getDatabaseEntities(project: ProjectState): DefinitionEntityState[];
+export declare function resolvePrimaryKeyProperty(entity: DefinitionEntityState): PropertyState | null;
+export declare function resolvePersistedDefinitionEntityDatabaseEntity(entity: DefinitionEntityState): DefinitionEntityState | null;
+export declare function getColumnProperties(entity: DefinitionEntityState): PropertyState[];
+/**
+ * Returns the database entity assigned to the given definition entity
+ *
+ * @param {DefinitionEntityState} entity - The definition entity (assumed to be persisted) for which to retrieve the assigned database entity.
+ * @returns {DefinitionEntityState | null} The database entity assigned to the given definition entity, or null if not found or if the input entity is invalid.
+ */
+export declare function getDatabaseEntity(entity: DefinitionEntityState): DefinitionEntityState | null;
+export declare function resolveClonedEntityProject(newParent: EntityState | null, self: EntityState): ProjectState;
+export declare function getStateClassFromType(entityType: EntityType): EntityStateConstructor | null;
+export declare function fromChangeSetToRecordChangeSet<TSelf extends {
+    id: string;
+    type: EntityType;
+} | null = EntityState, TGeneric extends {
+    id: string;
+    type: EntityType;
+} = EntityState>(changeSet: IChangeSet<TSelf, TGeneric>): IRecordChangeSet<TSelf, TGeneric>;
+export declare function checkHasMetadataChanged(currentEntityState: EntityState, newMetadata: Partial<Element | ElementTransfer | ElementShallowTransfer>): boolean;
+export declare function handleMetadataChange(self: UserManagedEntityState, data: Partial<Element | ElementTransfer | ElementShallowTransfer>, changeSet: ChangeSet | null): Partial<Element | ElementTransfer | ElementShallowTransfer>;
+export declare function getRecursiveParentsIds(entity: Element | ElementTransfer | ElementShallowTransfer | EntityState, allKnownEntities?: Record<EntityId, Element | ElementTransfer | ElementShallowTransfer | EntityState>): EntityId[];
+/**
+ * Get the touched canvas entities from the change set (added, updated, affected).
+ * @param {ChangeSet} changeSet The change set to extract the touched canvas entities from
+ * @returns {CanvasEntityState[]} An array of touched canvas entities
+ */
+export declare function getTouchedCanvasEntitiesFromChangeSet(changeSet: ChangeSet, options?: {
+    shallowMissingActivesError?: boolean;
+    excludeAffected?: boolean;
+    excludeAdded?: boolean;
+    excludeUpdated?: boolean;
+}): CanvasEntityState[];
+export declare function getDeclarationOutputedError(entity: PassThroughCallableEntityState): InputMapState | ValueDescriptorState | null;
+export declare function getDefaultRelationalDatabaseEntityOrFirst(project: ProjectState): DefinitionEntityState | null;
+export declare function checkIsBuiltIn(entity: UserManagedEntityState, project: ProjectState): boolean;
+export declare function getTopLevelParentEntityId(entity: EntityState): EntityId | null;
+export declare function checkShouldInputOrOutputBePartOfFinalVariableObjectValue(entity: InputMapState | OutputMapState): boolean;
+export declare function checkShouldPropertyBePartOfFinalVariableObjectValue(entity: PropertyState): boolean;
+export declare function getAllVariablesInScope(project: ProjectState, variableDeclarations: VariableDeclarationState[], targetEntity?: UserManagedEntityState): VariableDeclarationState[];
+/**
+ * Given two function-declarations or action-descriptors
+ * That could be implementations or extensions of each other
+ * It returns the top-level one.
+ *
+ * @param a
+ * @param b
+ * @returns {FunctionDeclarationState | ActionDescriptorState | null}
+ */
+export declare function getTopLevelFunctionDeclarationOrActionDescriptor(a: FunctionDeclarationState | ActionDescriptorState, b: FunctionDeclarationState | ActionDescriptorState): FunctionDeclarationState | ActionDescriptorState | null;
+/**
+ * Given a function-declaration, it returns the lowest level implemented or extended entity (function declaration or action descriptor)
+ *
+ * @param entity
+ * @returns {FunctionDeclarationState | ActionDescriptorState | null}
+ */
+export declare function getLowestFunctionDeclarationOrActionDescriptorImplementation(entity: FunctionDeclarationState | ActionDescriptorState): FunctionDeclarationState | ActionDescriptorState;
+export declare function checkIsRequiredValue(entity: EntityWithValueState | PropertyState | ValueDescriptorState): boolean;
+export declare function modifyEditableAndDeletableDownstreamEntitiesFromGiven(entity: UserManagedEntityState, changeSet: ChangeSet, newValue: boolean, seenEntities?: Set<string>): void;
+export declare function freezeDownstreamEntitiesFromGiven(entity: UserManagedEntityState, changeSet: ChangeSet, seenEntities?: Set<string>): void;
+export declare function unfreezeDownstreamEntitiesFromGiven(entity: UserManagedEntityState, changeSet: ChangeSet, seenEntities?: Set<string>): void;
+export declare function entitiesToUniqueCanvasEntities(entities: EntityState[], filterOut?: string[]): CanvasEntityState[];
+/**
+ * Sometimes a value reading entity might be reading values from an entity which its is not allowed.
+ * All value reading entities need to be called-by, directly or indirectly, by a value writing entity.
+ * For example: An input-map of an operation that reads the value of a variable-instance. The var instance needs to call the operation
+ * If the operation is calling the var instance, or an ancestor of it, then it is not valid and we can't fix it
+ *
+ * @param {ValueReadingEntityState} entity
+ * @param {ChangeSet | null} changeSet
+ *
+ * @returns { valid: boolean; }
+ */
+export declare function bestEffortRecalculateCallerForExistingValueWriter(entity: ValueReadingEntityState, changeSet: ChangeSet | null): {
+    valid: boolean;
+    newCallerEntity: CallerEntityState | null;
+};
+export declare function getAllValueReadingChildren(entity: CanvasEntityState | InternalCallState): ValueReadingEntityState[];
+export declare function getAllValueWritingChildren(entity: CanvasEntityState | InternalCallState): ValueWritingEntityState[];
+export declare function getAllValueWritingEntities(project: ProjectState, options?: YieldOptions): Promise<ValueWritingEntityState[]>;
+export declare function getAllGlobalValueWritingEntities(project: ProjectState, options?: YieldOptions): Promise<ValueWritingEntityState[]>;
+export declare function getAllGlobalValueReadingEntities(project: ProjectState, options?: YieldOptions): Promise<ValueReadingEntityState[]>;
+export declare function removeRedundantCallers(entity: CallableEntityState, changeSet: ChangeSet | null, options?: {
+    onCallRemoved?: (caller: CallerEntityState, callee: CallableEntityState, callType: 'success' | 'error' | 'entry' | 'loop-body') => Promise<void>;
+}): Promise<ChangeSet | null>;
+/**
+ * Recursively resolves all entities that can throw errors and don't catch them, or call logic upon error
+ * from the entry point, and without own ancestors or conditions or itself
+ *
+ * @param {CallableEntityState} entity The entity to resolve pass through entities with outputs for
+ * @returns {{ ancestor: PassThroughCallableEntityWithOutputsState, call: CallableEntityState, callType: ('success'|'error') }[]} An array of independent parallel conditions direct calls
+ */
+export declare function resolveAllParallelAncestorErrorCallersForEntity(entity: CallableEntityState): {
+    caller: PassThroughCallableEntityWithOutputsState;
+}[];

package/dist/tree/utils/literal-value.d.ts

@@ -0,0 +1,8 @@
+import { LiteralValueType } from '../../definitions';
+import { LiteralValueState } from '../state';
+
+export declare function checkIsEmptyValue(value: LiteralValueType | undefined): boolean;
+export declare function checkIsExplicitlyEmpty(value: LiteralValueType | undefined): boolean;
+export declare function checkIsLiteralValueEmpty(value: LiteralValueState | null): boolean;
+export declare function checkIsLiteralValueExplicitlyEmpty(value: LiteralValueState | null): boolean;
+export declare function areLiteralValuesEqual(valueA: LiteralValueState, valueB: LiteralValueState): boolean;

package/dist/tree/utils/log/index.d.ts

@@ -0,0 +1,3 @@
+export * from './log-entity';
+export * from './log-call-stack';
+export * from './project';

package/dist/tree/utils/log/log-call-stack.d.ts

@@ -0,0 +1,13 @@
+import { EntityState, CallerEntityState, EntityWithValueState } from '../../state';
+
+export interface ILogicPrintOptions {
+    indentSize?: number;
+    maxDepth?: number;
+    onPrefix?: (entity: EntityState) => string;
+    onMissingValue?: (entity: EntityWithValueState, defaultLabel: string) => string;
+}
+/**
+ * Generates a pseudo-code representation of the call stack/logic flow
+ * starting from a specific entity (usually a FunctionDeclaration).
+ */
+export declare function printLogicCallStack(startEntity: CallerEntityState, options?: ILogicPrintOptions): string;