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

package/dist/tree/utils/log/log-entity.d.ts

@@ -0,0 +1,106 @@
+import { ElementGenerationTarget, EntityType } from '../../../definitions';
+import { ArgumentDeclarationState, DataTypeState, DefinitionEntityState, EntityState, EntityWithDefaultValueState, EntityWithValueState, InputMapState, OutputMapState, PassThroughCallableEntityWithOutputsState, ProjectState, ValueDescriptorState, ValueWritingEntityState } from '../../state';
+
+export interface IPrintEntityOptions {
+    nested?: boolean;
+    omitTopLevelType?: boolean;
+    firstLabel?: 'name' | 'id';
+    omitIdsFor?: EntityType[];
+    omitTypesFor?: EntityType[];
+    metadataIndent?: number;
+    ownMetadataIndent?: number;
+    omitFields?: EntityPrintingFields[];
+    onlyFields?: EntityPrintingFields[];
+    onPrefix?: (entity: EntityState) => string;
+    onMissingValue?: (entity: EntityWithValueState, defaultLabel: string) => string;
+}
+export declare function printDefEntityBuiltInFunctionality(entity: DefinitionEntityState): string;
+export declare function printGenerationTarget(entity: ElementGenerationTarget, project: ProjectState): string;
+export declare function printDataType(dataType: DataTypeState | null, options?: IPrintEntityOptions): {
+    lines: {
+        text: string;
+        indentLevel: number;
+    }[];
+};
+export declare enum EntityPrintingFields {
+    All = "all",
+    Callers = "callers",
+    ReadsValue = "reads-value",
+    WritesValues = "writes-values",
+    Declaration = "declaration",
+    Id = "id",
+    Type = "type",
+    Name = "name",
+    Description = "description",
+    Extends = "extends",
+    Implements = "implements",
+    CodeName = "code-name",
+    DataType = "data-type"
+}
+export declare function generateValueAssignmentLogLine(entity: EntityWithDefaultValueState, options?: IPrintEntityOptions & {
+    prefix?: string;
+}): string;
+export declare function generateWritesValuesToLogLine(entity: ValueWritingEntityState, options?: IPrintEntityOptions & {
+    prefix?: string;
+}): {
+    lines: {
+        text: string;
+        indentLevel: number;
+    }[];
+};
+export declare function generateOutputMaps(outputs: OutputMapState[], options?: IPrintEntityOptions & {
+    label?: string;
+}): {
+    lines: {
+        text: string;
+        indentLevel: number;
+    }[];
+};
+export declare function generateInputMaps(inputs: (InputMapState | ArgumentDeclarationState | ValueDescriptorState)[], options?: IPrintEntityOptions & {
+    label?: string;
+    firstListItemIndent?: number;
+    otherListItemIndent?: number;
+}): {
+    lines: {
+        text: string;
+        indentLevel: number;
+    }[];
+};
+export declare function generateDataType(dataType: DataTypeState | null, options?: IPrintEntityOptions): {
+    lines: {
+        text: string;
+        indentLevel: number;
+    }[];
+};
+export declare function generateCaughtErrorOutputLogLines(entity: PassThroughCallableEntityWithOutputsState, options?: IPrintEntityOptions & {
+    prefix?: string;
+}): {
+    lines: {
+        text: string;
+        indentLevel: number;
+    }[];
+};
+export declare function printEntity(entity: EntityState, options?: IPrintEntityOptions): {
+    lines: {
+        text: string;
+        indentLevel: number;
+    }[];
+};
+export interface IEntityPrintoutOptions {
+    singleLine?: boolean;
+    indentSize?: number;
+    singleLineSpacer?: string;
+}
+export declare function assembleEntityPrintout(entityPrintout: {
+    lines: {
+        text: string;
+        indentLevel: number;
+    }[];
+}, options?: {
+    singleLine?: boolean;
+    indentSize?: number;
+    singleLineSpacer?: string;
+}): string;
+export declare function printEntityList(entities: EntityState[], options?: IPrintEntityOptions, printoutOptions?: IEntityPrintoutOptions & {
+    newLinesBetweenItems?: number;
+}): string;

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

@@ -0,0 +1,6 @@
+import { ProjectState } from '../../state';
+import { IEntityPrintoutOptions, IPrintEntityOptions } from './log-entity';
+
+export declare function generateFullProjectPrintout(project: ProjectState, options?: IPrintEntityOptions, printoutOptions?: IEntityPrintoutOptions & {
+    newLinesBetweenItems?: number;
+}): string;

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

@@ -0,0 +1,79 @@
+import { BaseEntityNames, ElementGenerationTarget, ElementShallowTransfer, ElementTransfer, IArgumentDeclarationGenerationTarget, IArgumentDeclarationShallowTransfer, IArgumentDeclarationTransfer, IDefinitionEntityGenerationTarget, IDefinitionEntityShallowTransfer, IDefinitionEntityTransfer, IFunctionDeclarationGenerationTarget, IFunctionDeclarationShallowTransfer, IFunctionDeclarationTransfer, IPropertyGenerationTarget, IPropertyShallowTransfer, IPropertyTransfer, IVariableDeclarationGenerationTarget, IVariableDeclarationShallowTransfer, IVariableDeclarationTransfer, PrimitiveTypes, EntityWithNames } from '../../definitions';
+import { ArgumentDeclarationState, BuiltInBaseEntityState, ConditionState, DefinitionEntityState, DataTypeState, EntityPayloadUnion, EntityWithValueState, FunctionDeclarationState, ActionDescriptorState, ProjectState, PropertyState, SearchState, VariableDeclarationState, ValueDescriptorState, ChangeSet } from '../state';
+import { EntityGenerationError } from '../state/error';
+
+/**
+ * First letter of each word is lowercase and the rest of the words, start in uppercase
+ * someName
+ *
+ * @param str - The string to convert to camelCase
+ * @returns The camelCase version of the string
+ */
+export declare function toCamelCase(str: string): string;
+/**
+ * First letter is uppercase; the rest of each word is left intact
+ * SomeName or BlogContent or BlogCONTENT
+ *
+ * @param str - The string to convert to PascalCase
+ * @returns The PascalCase version of the string
+ */
+export declare function toPascalCase(str: string): string;
+/**
+ * Words keep their original capitalization; we just insert dashes
+ * some-name or SOME-NAME or Some-Name or sOme-NaMe
+ *
+ * @param str - The string to convert to kebab-case
+ * @returns The kebab-case version of the string
+ */
+export declare function toKebabCase(str: string): string;
+/**
+ * Words keep their original capitalization; we just insert underscores
+ * some_name or SOME_NAME or Some_Name or sOme_NaMe
+ *
+ * @param str - The string to convert to snake_case
+ * @returns The snake_case version of the string
+ */
+export declare function toSnakeCase(str: string): string;
+/**
+ * Convert a string to kebab-case and then to lower case.
+ *
+ * @param str - The string to convert to lower case kebab-case
+ * @returns The lower case kebab-case version of the string
+ */
+export declare function toLowerCaseKebabCase(str: string): string;
+/**
+ * Converts a code-like identifier into a human-readable sentence:
+ * - turns underscores and dashes into spaces
+ * - splits words before uppercase letters (e.g. camelCase, PascalCase, ABBRStyle)
+ * - collapses multiple spaces
+ * - capitalizes only the first letter of the entire sentence
+ *
+ * @param str - The string to convert to sentence case
+ * @returns The sentence-case version of the string
+ */
+export declare function toSentenceCase(str: string): string;
+export declare function resolveDataTypeLabel(dataType: DataTypeState | null): string;
+export declare function resolveEntityDataTypeLabel(entity: PropertyState | EntityWithValueState | ValueDescriptorState): string;
+export declare function resolveConditionOperatorLabel(condition: ConditionState): "is equal to" | "is not equal to" | "is empty" | "is present" | "is greater than" | "is greater than or equal to" | "is less than" | "is less than or equal to" | "contains" | "starts with" | "ends with" | "is false" | "is true" | "and" | "or" | undefined;
+export declare function resolveBaseEntityName(baseEntities: BaseEntityNames[]): string;
+export declare function resolveTechnicalBaseEntityName(baseEntities: BaseEntityNames[]): string;
+export declare function resolveBuiltInBaseEntityDataTypeLabel(entity: BuiltInBaseEntityState): string;
+export declare function resolveDefinitionEntityDataTypeLabel(entity: DefinitionEntityState): string;
+export declare function resolveSearchName(search: SearchState): string;
+export declare function resolvePrimitiveEntityName(primitiveEntity: {
+    name: PrimitiveTypes;
+    [key: string]: any;
+}): string;
+export declare function resolveActionDescriptorName(actionDescriptor: ActionDescriptorState): string;
+export declare function resolveEntityName(entity: EntityPayloadUnion, project: ProjectState): string;
+export declare function safeResolveEntityName(entity: EntityPayloadUnion, project: ProjectState, fallback?: string): string;
+export declare function validateDefinitionEntityName(entity: DefinitionEntityState | IDefinitionEntityGenerationTarget | IDefinitionEntityShallowTransfer | IDefinitionEntityTransfer, project: ProjectState): EntityGenerationError[];
+export declare function validateFunctionDeclarationName(entity: FunctionDeclarationState | IFunctionDeclarationGenerationTarget | IFunctionDeclarationShallowTransfer | IFunctionDeclarationTransfer, project: ProjectState): EntityGenerationError[];
+export declare function validateVariableDeclarationName(entity: VariableDeclarationState | IVariableDeclarationGenerationTarget | IVariableDeclarationShallowTransfer | IVariableDeclarationTransfer, project: ProjectState): EntityGenerationError[];
+export declare function validatePropertyName(entity: PropertyState | IPropertyGenerationTarget | IPropertyShallowTransfer | IPropertyTransfer, project: ProjectState): EntityGenerationError[];
+export declare function validateArgumentDeclarationName(entity: ArgumentDeclarationState | IArgumentDeclarationGenerationTarget | IArgumentDeclarationShallowTransfer | IArgumentDeclarationTransfer, project: ProjectState): EntityGenerationError[];
+export declare function validateName(entity: ElementGenerationTarget | ElementShallowTransfer | ElementTransfer, project: ProjectState): EntityGenerationError[];
+export declare function resolveEntityCodeName(entity: EntityPayloadUnion, project: ProjectState): string | null;
+export declare function findNextAvailableName(baseName: string, allEntitiesOfType: EntityWithNames[]): string;
+export declare function renameDefToNextAvailableName(entity: DefinitionEntityState, changeSet: ChangeSet | null): void;
+export declare function resolveActionDescriptorNameById(id: string): string | null;

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

@@ -0,0 +1,4 @@
+import { Element, ElementGenerationTarget, ElementShallowTransfer, ElementTransfer, IGenericReference } from '../../definitions';
+import { EntityState } from '../state';
+
+export declare function getReferenceEntityId(reference: string | IGenericReference | EntityState | Element | ElementShallowTransfer | ElementTransfer | ElementGenerationTarget | null): string | null;

package/dist/tree/utils/shared-data-structure-entity.d.ts

@@ -0,0 +1,45 @@
+import { DataTypeParentChildRelation, EntityId } from '../../definitions';
+import { BuiltInBaseEntityState, DefinitionEntityState, DataTypeState, EntityState, IChangeSet, ProjectState, PropertyState, ChangeSet, EntityError, FunctionDeclarationState, SharedEntityErrorCode, ActionDescriptorState } from '../state';
+
+export declare function handleBeforeEntityImplementationSideEffects(self: DefinitionEntityState | BuiltInBaseEntityState, changeSet: ChangeSet | null): {
+    newEntities: EntityState[];
+};
+export declare function handleAfterEntityImplementationSideEffects(implemented: DefinitionEntityState, changeSet: ChangeSet | null): IChangeSet<DefinitionEntityState>;
+export declare function implement(self: DefinitionEntityState | BuiltInBaseEntityState, newEntityName: string, changeSet: ChangeSet | null, newId?: string): DefinitionEntityState;
+export declare function findEntityFromKeys(keys: string[], project: ProjectState): DefinitionEntityState | null;
+export declare function createNestedDataTypeForEntity(entity: DefinitionEntityState, parentDataType: DataTypeState, changeSet: ChangeSet | null, parentRelationType?: DataTypeParentChildRelation): IChangeSet<DataTypeState>;
+export declare function resolveDataTypeEntityOrNestedChildrenFromLiteralValue(value: any, parentDataType: DataTypeState, newDefinitionEntityMetadata: {
+    id?: EntityId;
+    name: string;
+    description?: string;
+    static?: boolean;
+    abstract?: boolean;
+}, changeSet: ChangeSet | null, rootEntityCreated: DefinitionEntityState): IChangeSet<DataTypeState>;
+export declare function createDefinitionEntityFromJSONObject(data: {
+    [key: string]: any;
+}, project: ProjectState, definitionEntityMetadata: {
+    id?: EntityId;
+    name: string;
+    description?: string;
+    static?: boolean;
+    abstract?: boolean;
+}, changeSet: ChangeSet | null, rootEntityCreated?: DefinitionEntityState): {
+    hasCreated: boolean;
+    changeSet: IChangeSet<DefinitionEntityState>;
+};
+/**
+ * Checks wether two sets of implementable entities like properties or methods, presumably from two different entities, have overlap
+ * This means that entities on both lists have have the same name or implement the same base entity/descriptor
+ */
+export declare function checkImplementationsOverlap(higherEntities: PropertyState[], baseEntities: PropertyState[], implementationErrorCode: SharedEntityErrorCode.PropertyOverwritesBasePropertyWithSameImplementation | SharedEntityErrorCode.PropertyOverwritesOtherImplementedEntitysPropertyWithSameImplementation | SharedEntityErrorCode.PropertyOverwritesOtherExtendedEntitysPropertyWithSameImplementation | SharedEntityErrorCode.PropertyOverwritesOtherSiblingWithSameImplementation, nameErrorCode: SharedEntityErrorCode.PropertyOverwritesBasePropertyWithSameName | SharedEntityErrorCode.PropertyOverwritesOtherImplementedEntitysPropertyWithSameName | SharedEntityErrorCode.PropertyOverwritesOtherExtendedEntitysPropertyWithSameName | SharedEntityErrorCode.PropertyOverwritesOtherSiblingWithSameName): {
+    errors: EntityError[];
+    overlap: boolean;
+};
+export declare function checkImplementationsOverlap(higherEntities: (FunctionDeclarationState | ActionDescriptorState)[], baseEntities: (FunctionDeclarationState | ActionDescriptorState)[], implementationErrorCode: SharedEntityErrorCode.MethodOverwritesBaseMethodWithSameImplementation | SharedEntityErrorCode.MethodOverwritesOtherImplementedEntitysMethodWithSameImplementation | SharedEntityErrorCode.MethodOverwritesOtherExtendedEntitysMethodWithSameImplementation | SharedEntityErrorCode.MethodOverwritesOtherSiblingWithSameImplementation, nameErrorCode: SharedEntityErrorCode.MethodOverwritesBaseMethodWithSameName | SharedEntityErrorCode.MethodOverwritesOtherImplementedEntitysMethodWithSameName | SharedEntityErrorCode.MethodOverwritesOtherExtendedEntitysMethodWithSameName | SharedEntityErrorCode.MethodOverwritesOtherSiblingWithSameName): {
+    errors: EntityError[];
+    overlap: boolean;
+};
+export declare function convertToAbstract(entity: DefinitionEntityState, changeSet: ChangeSet): DefinitionEntityState;
+export declare function convertToNonAbstract(entity: DefinitionEntityState, changeSet: ChangeSet): DefinitionEntityState;
+export declare function convertToStatic(entity: DefinitionEntityState, changeSet: ChangeSet): DefinitionEntityState;
+export declare function convertToNonStatic(entity: DefinitionEntityState, changeSet: ChangeSet): DefinitionEntityState;

package/dist/tree/utils/sql-migrations.d.ts

@@ -0,0 +1,70 @@
+import { EntityId } from '../../definitions';
+import { ChangeSet, DefinitionEntityState, ProjectState, PropertyState } from '../state';
+
+export interface ISQLMigrationsDiffs {
+    changesSinceLastPublication: boolean;
+    rowTransformerNeeded: boolean;
+    newestOpenRowTransformer: DefinitionEntityState | null;
+    newRowTransformerNeeded: boolean;
+    newRequiredProperties: PropertyState[];
+    newNonRequiredProperties: PropertyState[];
+    deletedProperties: PropertyState[];
+    lastPublishedEntityVersion: DefinitionEntityState | null;
+    updatedEntityVersion: DefinitionEntityState;
+    nameChange?: {
+        from: string;
+        to: string;
+    };
+    propChanges: Map<EntityId, {
+        castableDataTypeEntity?: {
+            fromId: EntityId;
+            toId: EntityId;
+        };
+        nonCastableDataTypeEntity?: {
+            fromId: EntityId;
+            toId: EntityId;
+        };
+        newForeignKeyRef?: PropertyState;
+        oldForeignKeyRef?: PropertyState;
+        nameChange?: {
+            from: string;
+            to: string;
+        };
+        requiredChange?: {
+            from: boolean;
+            to: boolean;
+        };
+        property: PropertyState;
+        oldProperty: PropertyState;
+    }>;
+    isPreexistingRowTransformerUpToDate: boolean | null;
+    extendedEntities: ISQLMigrationsDiffs[];
+}
+export declare function checkIsRowTransformerUpToDate(newestOpenRowTransformer: DefinitionEntityState, entity: DefinitionEntityState, lastPublishedEntityVersion: DefinitionEntityState): {
+    isPreexistingRowTransformerUpToDate: boolean;
+};
+export declare function resolveSQLMigrationsDiffs(project: ProjectState, lastPublishedProjectState: ProjectState | null, entity: DefinitionEntityState, options?: {
+    skipBaseExtension?: boolean;
+}): ISQLMigrationsDiffs;
+/**
+ * Modifies the given transformer so the arguments of the 'up' method's body match the properties of the old entity state
+ * The returned structure matches that of the new entity state
+ *
+ * And does the oposite to the 'down' method's body so the return is the old entity and the input args are the new entity
+ *
+ * @param {EditorService} editor
+ * @param {DefinitionEntityState} transformer
+ * @param {DefinitionEntityState} newEntityState
+ * @param {DefinitionEntityState} oldEntityState
+ */
+export declare function addDifferencesToRowTransformer(project: ProjectState, transformer: DefinitionEntityState, newEntityState: DefinitionEntityState, oldEntityState: DefinitionEntityState, changeSet: ChangeSet): void;
+export declare function generateNewRowMigrationDefinition(project: ProjectState, updatedEntity: DefinitionEntityState, lastPublishedEntityVersion: DefinitionEntityState, changeSet: ChangeSet, offsets?: {
+    x?: number;
+    y?: number;
+}): DefinitionEntityState;
+export declare function createOrUpdateRowTransformer(project: ProjectState, diffs: ISQLMigrationsDiffs, changeSet: ChangeSet, offsets?: {
+    x?: number;
+    y?: number;
+}): {
+    rowTransformer: DefinitionEntityState;
+};

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

@@ -0,0 +1,2 @@
+export declare function capitalizeFirstLetter(value: string): string;
+export declare function lowercaseFirstLetter(value: string): string;

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

@@ -0,0 +1,48 @@
+import { ElementTransfer, Element, EntityId, ElementShallowTransfer } from '../../definitions';
+import { EntityState } from '../state';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare function isPromise(obj: any): obj is Promise<any>;
+export declare function orderEntitiesForTraversal(entities: (Element | ElementTransfer | EntityState | ElementShallowTransfer)[], options: {
+    allBuiltInEntityIds?: Set<EntityId>;
+}): (Element | ElementTransfer | EntityState | ElementShallowTransfer)[];
+export declare function getRecordOrderForTraversal(entities: Record<EntityId, Element | ElementTransfer | EntityState | ElementShallowTransfer>, options: {
+    allBuiltInEntityIds?: Set<EntityId>;
+}): EntityId[];
+export declare function orderEntitiesForTraversalAsync(entities: (Element | ElementTransfer | EntityState | ElementShallowTransfer)[], options: {
+    allBuiltInEntityIds?: Set<EntityId>;
+} & YieldOptions): Promise<(Element | ElementTransfer | EntityState | ElementShallowTransfer)[]>;
+export declare function getRecordOrderForTraversalAsync(entities: Record<EntityId, Element | ElementTransfer | EntityState | ElementShallowTransfer>, options: {
+    allBuiltInEntityIds?: Set<EntityId>;
+} & YieldOptions): Promise<EntityId[]>;
+export declare class Traverser {
+    order: EntityId[];
+    flatRecord: Record<EntityId, Element | ElementTransfer | EntityState | ElementShallowTransfer>;
+    allBuiltInEntityIds: Set<EntityId>;
+    private onGoingVisits;
+    cachedReferences: Record<EntityId, {
+        upstream: Record<EntityId, true>;
+        downstream: Record<EntityId, true>;
+    }>;
+    constructor(root?: Element | ElementTransfer | EntityState | ElementShallowTransfer, options?: {
+        asyncInitial?: boolean;
+        onOrdered?: () => void;
+        allBuiltInEntityIds?: Set<EntityId>;
+    } & YieldOptions);
+    flatten(entity: Element | ElementTransfer | EntityState | ElementShallowTransfer): void;
+    flattenAsync(entity: Element | ElementTransfer | EntityState | ElementShallowTransfer, options?: YieldOptions): Promise<void>;
+    private moveEntityAfterDependencies;
+    orderEntities(): void;
+    orderEntitiesAsync(options?: YieldOptions): Promise<void>;
+    getUpstreamOngoingDependenciesVisits(entityId: EntityId, taskId: string): Record<EntityId, Promise<any>>;
+    getDownstreamOngoingDependenciesVisits(entityId: EntityId, taskId: string): Record<EntityId, Promise<any>>;
+    settlePromises(promises: Record<EntityId, Promise<any>>, taskId: string): Promise<void>;
+    visit(callback: (entity: Element | ElementTransfer | EntityState | ElementShallowTransfer, knownEntitiesRecord: Record<EntityId, Element | ElementTransfer | EntityState | ElementShallowTransfer>) => any): Traverser;
+    reverseVisit(callback: (entity: Element | ElementTransfer | EntityState | ElementShallowTransfer, knownEntitiesRecord: Record<EntityId, Element | ElementTransfer | EntityState | ElementShallowTransfer>) => any): Traverser;
+    visitAsync(callback: (entity: Element | ElementTransfer | EntityState | ElementShallowTransfer, knownEntitiesRecord: Record<EntityId, Element | ElementTransfer | EntityState | ElementShallowTransfer>) => any, options?: {
+        parallelise?: boolean;
+    } & YieldOptions): Promise<Traverser>;
+    reverseVisitAsync(callback: (entity: Element | ElementTransfer | EntityState | ElementShallowTransfer, knownEntitiesRecord: Record<EntityId, Element | ElementTransfer | EntityState | ElementShallowTransfer>) => any, options?: {
+        parallelise?: boolean;
+    } & YieldOptions): Promise<Traverser>;
+}

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

@@ -0,0 +1,9 @@
+import { ElementGenerationTarget, EntityType } from '../../definitions';
+import { EntityState } from '../state';
+import { ProjectState } from '../state/project/project';
+
+export declare function createSemanticId(entityName: string, entityType: EntityType, project: ProjectState): string;
+export declare function suggestNewIdForEntity(generatedEntity: ElementGenerationTarget, projectState: ProjectState): string;
+export declare function generateIdFromStrategy(entity: EntityState, project: ProjectState, strategy?: 'uuid' | 'semantic'): string;
+export declare function isUUID(uuid: string): boolean;
+export declare function isUUIDv4(uuid: unknown): uuid is string;

package/dist/tree/utils/validation-utils.d.ts

@@ -0,0 +1,138 @@
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+import { ArgumentDeclarationState, CallableEntityState, CallerEntityState, ChangeSet, EntityError, ExecutableEntityState, GenerationExplanationIds, InputMapState, LoopState, OutputMapState, PassThroughCallableEntityState, StateMutationErrorCode, UserManagedEntityState, ValueDescriptorState, VariableState } from '../state';
+import { EntityId, EntityType } from '../../definitions';
+
+export declare enum CanvasEntityConnectionDisabledReason {
+    ValuesAlreadyConnected = "values-already-connected",
+    CannotReadMoreThanOneValue = "cannot-read-more-than-one-value",
+    CannotReadValueFromChildren = "cannot-read-value-from-children",
+    CannotBeCalledByChildren = "cannot-be-called-by-children",
+    ExecutionsAlreadyConnected = "executions-already-connected",
+    DataTypesNotCompatible = "data-types-not-compatible",
+    CannotCallAncestor = "cannot-call-ancestor",
+    CannotConnectToItself = "cannot-connect-to-itself",
+    CannotWriteValueToAncestor = "cannot-write-value-to-ancestor",
+    NotInScope = "not-in-scope",
+    IsNotValueWritingEntity = "is-not-value-writing-entity",
+    IsNotValueReadingEntity = "is-not-value-reading-entity",
+    ContinueOrBreakStatementCalledFromOutsideLoop = "continue-or-break-statement-called-from-outside-loop",
+    ElementInLoopBodyCallingOutsideLoop = "element-in-loop-body-calling-outside-loop",
+    CallerIsInHigherScope = "caller-is-in-higher-scope",
+    CallerIsInLowerScope = "caller-is-in-lower-scope",
+    CallIsInHigherScope = "call-is-in-higher-scope",
+    CallIsInLowerScope = "call-is-in-lower-scope",
+    CalledBySourceMustBeCallerEntity = "called-by-source-must-be-caller-entity",
+    OtherIncompatibleScopeReason = "other-incompatible-scope-reason",
+    SiblingInternalCallAlreadyUsedInParentVariable = "sibling-internal-call-already-used-in-parent-variable",
+    ErrorOututMapCannotBeConnectedToParentSuccessBranchCallees = "error-output-map-cannot-be-connected-to-parent-success-branch-callees",
+    SuccessOutputMapCannotBeConnectedToParentErrorBranchCallees = "success-output-map-cannot-be-connected-to-parent-error-branch-callees",
+    CannotInteractWithInputInVariableWithInternalCalls = "cannot-interact-with-input-in-variable-with-internal-calls",
+    CannotInteractWithOutputInVariableWithInternalCalls = "cannot-interact-with-output-in-variable-with-internal-calls",
+    CannotInteractWithInputInGlobalVariableDeclaration = "cannot-interact-with-input-in-global-variable-declaration",
+    PropertyIsConstantItsValueCantBeReset = "property-is-constant-its-value-cant-be-reset",
+    CannotWriteValueOfGlobalVariableDeclaration = "cannot-write-value-of-global-variable-declaration",
+    CannotCallGlobalVariableDeclaration = "cannot-call-global-variable-declaration",
+    CannotReSetValueOfConstantVariable = "cannot-reset-value-of-constant-variable",
+    CannotConnectToOwnNode = "cannot-connect-to-own-node",
+    VariableDeclarationCannotBeMovedToLowerScopeBecauseInstancesUsage = "variable-declaration-cannot-be-moved-to-lower-scope-because-instances-usage",
+    CannotChangeScopeBecauseItIsAlreadyCalledByOtherEntitiesInDifferentScope = "cannot-change-scope-because-it-is-already-called-by-other-entities-in-different-scope",
+    CannotChangeScopeBecauseItCallsOtherEntities = "cannot-change-scope-because-it-calls-other-entities",
+    CalledByErrorMustBePassThroughCallable = "called-by-error-must-be-pass-through-callable",
+    CalledByErrorCannotBeConnectedToEntitiesCalledByOwnSuccessBranch = "called-by-error-cannot-be-connected-to-entities-called-by-own-success-branch",
+    CalledBySuccessCannotBeConnectedToEntitiesCalledByOwnErrorBranch = "called-by-success-cannot-be-connected-to-entities-called-by-own-error-branch",
+    EntityAlreadyCalledBySuccessCannotBeConnectedToUnrelatedErrorBranch = "entity-already-called-by-success-cannot-be-connected-to-unrelated-error-branch",
+    RedundantCall = "redundant-call",
+    WouldMakeAnEarlierNodeBeCalledBeforeItsDeclaration = "would-make-an-earlier-node-be-called-before-its-declaration",
+    CannotBeCalledBeforeDeclaration = "cannot-be-called-before-declaration",
+    CannotBeCalledInParallelBranchToDeclaration = "cannot-be-called-in-parallel-branch-to-declaration",
+    CannotBeHigherScopeThanDeclaration = "cannot-be-higher-scope-than-declaration",
+    NotAConnectableEntityType = "not-a-connectable-entity-type",
+    IsNotCallerEntity = "is-not-caller-entity",
+    IsNotPassThroughCallableEntity = "is-not-pass-through-callable-entity",
+    IsNotCallableEntity = "is-not-callable-entity"
+}
+export declare const ALL_CONNECTION_DISABLED_REASONS: CanvasEntityConnectionDisabledReason[];
+export declare enum CanvasEntityTestingDisabledReason {
+    NotPartOfOngoingTest = "not-part-of-ongoing-test",
+    CannotBeAddedToTest = "cannot-be-added-to-test"
+}
+export declare const ALL_TESTING_DISABLED_REASONS: CanvasEntityTestingDisabledReason[];
+export declare enum CanvasEntityOtherDisabledReason {
+    Suggestion = "suggestion",
+    CanvasGloballyDisabled = "canvas-globally-disabled"
+}
+export declare const ALL_OTHER_DISABLED_REASONS: CanvasEntityOtherDisabledReason[];
+export type CanvasEntityDisabledReason = CanvasEntityConnectionDisabledReason | CanvasEntityTestingDisabledReason | CanvasEntityOtherDisabledReason | StateMutationErrorCode;
+export declare enum ConnectionNodeType {
+    PropertyOut = "property-out",
+    PropertyIn = "property-in",
+    EntryPointCaller = "entry-point-caller",
+    SuccessCaller = "success-caller",
+    ErrorCaller = "error-caller",
+    CalledBy = "called-by",
+    CalledByError = "called-by-error"
+}
+export interface ICompatibleConnectionOption {
+    requiresCallConnectionTo: CallableEntityState | null;
+    requiresCallConnectionToFrom: CallerEntityState | null;
+    entity: UserManagedEntityState;
+}
+export interface IConnectionCompatibleOptions {
+    [id: EntityId]: ICompatibleConnectionOption;
+}
+export interface IIncompatibleConnectionOption {
+    entity: UserManagedEntityState;
+    reasons: CanvasEntityConnectionDisabledReason[];
+    fixable: boolean;
+    requiresCallConnectionTo: CallableEntityState | null;
+    requiresCallConnectionToFrom: CallerEntityState | null;
+    nonAutofixableReasons: (CanvasEntityConnectionDisabledReason.VariableDeclarationCannotBeMovedToLowerScopeBecauseInstancesUsage | CanvasEntityConnectionDisabledReason.CannotChangeScopeBecauseItCallsOtherEntities | CanvasEntityConnectionDisabledReason.CannotChangeScopeBecauseItIsAlreadyCalledByOtherEntitiesInDifferentScope)[];
+}
+export interface IConnectionIncompatibleOptions {
+    [id: EntityId]: IIncompatibleConnectionOption;
+}
+export interface IConnectionCompatibilityResult {
+    compatible: IConnectionCompatibleOptions;
+    incompatible: IConnectionIncompatibleOptions;
+}
+export interface IGetConnectionCompatibilityOptions extends YieldOptions {
+    allowReadWriteToFixableScope?: boolean;
+}
+/**
+ * Returns a list of all entities that the current entity can connect to and not connect to
+ *
+ * @param {ArgumentDeclarationState | InputMapState | OutputMapState | LoopState | CallerEntityState | VariableState | ValueDescriptorState | ExecutableEntityState} entity The entity for which we want to find compatible and incompatible connections
+ * @param {ConnectionNodeType} connectionType The type of connection we want to create
+ * @param {YieldOptions & { allowReadWriteToFixableScope?: boolean }} options Additional options for the function, including yield options and whether to allow connections to entities that could become compatible if the scope is changed
+ *
+ * @returns {Promise<IConnectionCompatibilityResult>} An object containing two lists: one for compatible entities and one for incompatible entities, each with the reasons for their compatibility or incompatibility
+ */
+export declare function getIncompatibleConnectionEntitiesAsync(entity: ArgumentDeclarationState | InputMapState | OutputMapState | LoopState | CallerEntityState | VariableState | ValueDescriptorState | ExecutableEntityState, connectionType: ConnectionNodeType, options?: YieldOptions & {
+    allowReadWriteToFixableScope?: boolean;
+}): Promise<IConnectionCompatibilityResult>;
+export declare function moveParallelCalls(entity: PassThroughCallableEntityState, changeSet: ChangeSet, options?: {
+    onlyTypes?: EntityType[];
+    onConnection?: (sourceEntity: UserManagedEntityState, targetEntity: UserManagedEntityState, connectionType: ConnectionNodeType) => Promise<void>;
+    onCallRemoved?: (caller: CallerEntityState, callee: CallableEntityState, callType: 'success' | 'error' | 'entry' | 'loop-body') => Promise<void>;
+}): {
+    errors: EntityError[];
+    explanations: {
+        id: GenerationExplanationIds;
+        message: string;
+    }[];
+};
+/**
+ * Based what ultimately was connected ('sourceEntity', 'targetEntity' and 'connectionType'),
+ * and the initial compatibility result, we might need to apply some auto-fixes to make sure the connection is valid.
+ *
+ * @param {UserManagedEntityState} sourceEntity The entity from which the connection starts
+ * @param {UserManagedEntityState} targetEntity The entity to which the connection goes
+ * @param {ConnectionNodeType} connectionType The type of the connection that was made
+ * @param {ChangeSet} changeSet The changeset to which any potential change should be added
+ * @param {IConnectionCompatibilityResult} compatibilityResult The initial compatibility result before the connection was made, this will be used to determine if any auto-fix is needed, and which one
+ */
+export declare function applyConnectionCompatibilityAutoFixes(sourceEntity: UserManagedEntityState, targetEntity: UserManagedEntityState, connectionType: ConnectionNodeType, changeSet: ChangeSet, compatibilityResult: IConnectionCompatibilityResult, options?: {
+    onConnection?: (sourceEntity: UserManagedEntityState, targetEntity: UserManagedEntityState, connectionType: ConnectionNodeType) => Promise<void>;
+    onCallRemoved?: (caller: CallerEntityState, callee: CallableEntityState, callType: 'success' | 'error' | 'entry' | 'loop-body') => Promise<void>;
+}): Promise<void>;
+export declare function connectEntitiesBasedOnConenctionType(sourceEntity: UserManagedEntityState, targetEntity: UserManagedEntityState, connectionType: ConnectionNodeType, changeSet: ChangeSet): void;

package/dist/tree/utils/values-validations.d.ts

@@ -0,0 +1,11 @@
+import { LiteralValueType } from '../../definitions';
+import { EntityWithValueState, IValueValidationResult } from '../state';
+
+export declare enum CommonStringValidationErrorCodes {
+    ValueMustBeString = "value-must-be-string",
+    StringValueMustNotHaveSpaces = "string-value-must-not-have-spaces",
+    StringValueMustNotHaveDashes = "string-value-must-not-have-dashes",
+    MustBeUniqueAmongSameEntities = "must-be-unique-among-same-entities"
+}
+export declare function noSpacesValueValidation(self: EntityWithValueState, value: LiteralValueType): IValueValidationResult<LiteralValueType, CommonStringValidationErrorCodes>;
+export declare function noSpacesOrDashesValueValidation(self: EntityWithValueState, value: LiteralValueType): IValueValidationResult<LiteralValueType, CommonStringValidationErrorCodes>;

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

@@ -0,0 +1,7 @@
+import { EntityWithLogicScopeState, InputMapState, OutputMapState, ProjectState, PropertyState, VariableDeclarationState, VariableState } from '../state';
+
+export declare function getDeclaration(variable: VariableState): VariableDeclarationState;
+export declare function resolveVariableScope(variable: VariableState): 'global-declaration' | 'global-instance' | 'local-declaration' | 'local-instance';
+export declare function getVariablesInSameOrHigherScope(entity: EntityWithLogicScopeState | ProjectState, project: ProjectState): VariableDeclarationState[];
+export declare function propertyShouldBePartOfFinalVariableObjectValue(entity: PropertyState): boolean;
+export declare function inputOrOutputShouldBePartOfFinalVariableObjectValue(entity: InputMapState | OutputMapState): boolean;

package/dist/utils/arrays.d.ts

@@ -0,0 +1 @@
+export declare function mergeArraysOfStringsWithoutDuplicates(arr1: string[], arr2: string[]): string[];

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './object';
+export * from './arrays';

package/dist/utils/object.d.ts

@@ -0,0 +1,44 @@
+export declare function isObject(v: any): v is Record<string, unknown>;
+export type PathSegment = string | number;
+export type PathInput = string | Array<PathSegment>;
+/** lodash-like get(obj, path, defaultValue) with precise "missing" detection */
+export declare function get<T = any, D = any>(obj: any, path: PathInput, defaultValue?: D): T | D;
+interface SetOptions {
+    createMissing?: boolean;
+    coerce?: boolean;
+}
+/**
+ * lodash-like set(obj, path, value, options?)
+ * - Mutates `obj` (like lodash), returns it.
+ * - Creates arrays when next segment is numeric, otherwise objects (if createMissing=true).
+ * - Blocks prototype-polluting keys.
+ * - When createMissing=false, throws if any parent on the path is missing.
+ * - When coerce=false, throws if an existing non-container blocks traversal.
+ */
+export declare function set<T extends object = any>(obj: T, path: PathInput, value: any, options?: SetOptions): T;
+export declare function readObjectKey(obj: unknown, key: unknown): unknown;
+export declare function writeObjectKey(obj: unknown, key: unknown, value: unknown): Record<string, unknown>;
+export declare function deleteObjectKey(obj: unknown, key: unknown): Record<string, unknown>;
+export declare function readObjectNestedKey(obj: unknown, path: unknown, defaultValue?: unknown): unknown;
+/**
+ * Strict nested write (no auto-create).
+ * Throws if parent chain is missing.
+ */
+export declare function writeObjectNestedKey(obj: unknown, path: unknown, value: unknown): Record<string, unknown>;
+/**
+ * Safe nested write (auto-create parents).
+ */
+export declare function writeSafeObjectNestedKeyRecursively(obj: unknown, path: unknown, value: unknown): Record<string, unknown>;
+export declare function deleteObjectNestedKey(obj: unknown, path: unknown): Record<string, unknown>;
+export declare function objectHasKey(obj: unknown, key: unknown): boolean;
+export declare function objectKeyValueEquals(obj: unknown, key: unknown, expected: unknown): boolean;
+export declare function objectHasNestedKey(obj: unknown, path: unknown): boolean;
+export declare function nestedObjectKeyValueEquals(obj: unknown, path: unknown, expected: unknown): boolean;
+/**
+ * MergeObjects: shallow, immutable merge with rightmost-precedence.
+ */
+export declare function mergeObjects(...objs: unknown[]): Record<string, unknown>;
+export declare function objectKeys(obj: unknown): string[];
+export declare function objectValues(obj: unknown): unknown[];
+export declare function objectEntries(obj: unknown): [string, unknown][];
+export {};

package/dist/uuid.d.ts

@@ -0,0 +1,6 @@
+export interface IUUIDModule {
+    isBackup?: boolean;
+    uuid: () => string;
+    fromUUID: (uuid: string) => string;
+}
+export declare const DEFAULT_UUID_MODULE: IUUIDModule;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@elyx-code/project-logic-tree",
-	"version": "0.0.6999",
+	"version": "0.0.7000",
 	"author": "Sergio Herrero",
 	"license": "UNLICENSED",
 	"description": "An installable module which contains the type definitions and ephemeral state management for a projects' logic tree data structure",