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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/utils/index.d.ts

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

package/dist/utils/object.d.ts

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

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