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

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

@@ -1,543 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

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

@@ -1,13 +0,0 @@
-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;