@elyx-code/project-logic-tree 0.0.6814 → 0.0.6816

package/dist/index.d.ts

@@ -412,6 +412,21 @@ export declare type AnyEncoding = UtfEncoding | BinEncoding;
 
 export declare function appendToList(list: unknown, value: unknown, ...values: unknown[]): any[];
 
+/**
+ * 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 applyNewScope(self: CallableEntityState, changeSet: ChangeSet | null): void;
 
 export declare function applyQueuedToCached(opts: {
@@ -438,11 +453,11 @@ export declare class Area {
     calculationEntryPoint: Area;
     _onlyEntities: CanvasEntityState[] | null;
     private _changeSet;
-    constructor(entity: CanvasEntityState | ProjectState, index: number, calculationEntryPoint?: Area | null, changeSet?: ChangeSet);
+    constructor(entity: CanvasEntityState | ProjectState, index: number, calculationEntryPoint?: Area | null, changeSet?: ChangeSet | null);
     static autoGenerateLayout(entryPointEntity: CanvasEntityState | ProjectState, changeSet: ChangeSet | null, onlyEntities?: CanvasEntityState[]): CanvasEntityState[];
     static recursivelyAssembleChildrenAreas(renderedParents: Area[]): void;
-    get onlyEntities(): CanvasEntityState[] | null;
-    get changeSet(): ChangeSet | null;
+    get onlyEntities(): CanvasEntityState[];
+    get changeSet(): ChangeSet;
     set changeSet(changeSet: ChangeSet | null);
     findAreaInChildrenFromEntity(entity: CanvasEntityState): Area | null;
     findAreaFromEntity(entity: CanvasEntityState): Area | null;
@@ -9439,6 +9454,15 @@ export declare enum BaseValueDescriptorIds {
 
  export declare function calculateNewParentBasedOnCallers(self: CallableEntityState): EntityWithLogicScopeState | ProjectState;
 
+ /**
+  * Calculates how far down the top of the parent definition entity a method starts
+  * Methods are function-declaration entities nested inside definition-entities
+  * But their distance to the top changes based on their index among all other rendered methods as well as all properties the parent has.
+  */
+ export declare function calculateVerticalOffsetForMethod(method: FunctionDeclarationState): {
+     offset: number;
+ };
+
  export declare const CALLABLE_ENTITIES_EXPLANATION: string;
 
  export declare const CALLABLE_TYPES: EntityType[];
@@ -9765,7 +9789,7 @@ export declare enum BaseValueDescriptorIds {
  export declare function checkIsNestedScope(parent: EntityWithLogicScopeState | ProjectState, child: EntityWithLogicScopeState | ProjectState, project: ProjectState): boolean;
 
  /**
-  * Checks whether the given data-type allows for a null value.
+  * Checks whether the given data-type ALLOWS for a null value.
   * This is either because the 'entity' field is the primitive null-prototype
   * Or because it has a literal-value, with its value set to `null`
   * Or because the data-type is an or-group where at least one of its children meets the above requirements
@@ -9774,6 +9798,14 @@ export declare enum BaseValueDescriptorIds {
   */
  export declare function checkIsNullable(dataType: DataTypeState | null): boolean;
 
+ /**
+  * Checks whether the given data-type is either explicitly set to null, or is an or-group where all options are explicitly set to null. In other words, whether the data-type allows only for a null value and nothing else.
+  *
+  * @param {DataTypeState | null} dataType the data-type to check
+  * @returns {boolean} whether the given data-type is either explicitly set to null
+  */
+ export declare function checkIsOnlyNull(dataType: DataTypeState | null): boolean;
+
  export declare function checkIsRequiredValue(entity: EntityWithValueState | PropertyState | ValueDescriptorState): boolean;
 
  export declare function checkIsRowTransformerUpToDate(newestOpenRowTransformer: DefinitionEntityState, entity: DefinitionEntityState, lastPublishedEntityVersion: DefinitionEntityState): {
@@ -15392,6 +15424,10 @@ export declare enum BaseValueDescriptorIds {
 
  export declare function getAllValueWritingChildren(entity: CanvasEntityState | InternalCallState): ValueWritingEntityState[];
 
+ export declare function getAllValueWritingEntities(project: ProjectState, options?: YieldOptions): Promise<ValueWritingEntityState[]>;
+
+ export declare function getAllValueWrittingChildren(entity: CanvasEntityState | InternalCallState): ValueWritingEntityState[];
+
  export declare function getAllVariablesInScope(project: ProjectState, variableDeclarations: VariableDeclarationState[], targetEntity?: UserManagedEntityState): VariableDeclarationState[];
 
  export declare function getBaseBuiltInEntities(entity: DefinitionEntityState | BuiltInBaseEntityState): BuiltInBaseEntityState[];
@@ -18584,24 +18620,7 @@ export declare enum BaseValueDescriptorIds {
 
  export declare function getIncompatibleConnectionEntitiesAsync(entity: ArgumentDeclarationState | InputMapState | OutputMapState | LoopState | CallerEntityState | VariableState | ValueDescriptorState | ExecutableEntityState, connectionType: ConnectionNodeType, options?: YieldOptions & {
      allowReadWriteToFixableScope?: boolean;
- }): Promise<{
-     compatible: {
-         [id: string]: {
-             requiresCallConnectionTo: CallableEntityState | null;
-             requiresCallConnectionToFrom: CallerEntityState | null;
-             entity: EntityState;
-         };
-     };
-     incompatible: {
-         [id: string]: {
-             entity: EntityState;
-             reasons: CanvasEntityConnectionDisabledReason[];
-             fixable: boolean;
-             requiresCallConnectionTo: CallableEntityState | null;
-             requiresCallConnectionToFrom: CallerEntityState | null;
-         };
-     };
- }>;
+ }): Promise<IConnectionCompatibilityResult>;
 
  export declare function getIndexItem(list: unknown, index: unknown): any;
 
@@ -21322,6 +21341,30 @@ export declare enum BaseValueDescriptorIds {
       parent: EntityWithLogicScope | EntityWithLogicScopeReference | IProject | IProjectReference | ICondition | IConditionReference;
   }
 
+  export declare interface IConnectionCompatibilityResult {
+      compatible: IConnectionCompatibleOptions;
+      incompatible: IConnectionIncompatibleOptions;
+  }
+
+  export declare interface IConnectionCompatibleOptions {
+      [id: string]: {
+          requiresCallConnectionTo: CallableEntityState | null;
+          requiresCallConnectionToFrom: CallerEntityState | null;
+          entity: UserManagedEntityState;
+      };
+  }
+
+  export declare interface IConnectionIncompatibleOptions {
+      [id: string]: {
+          entity: UserManagedEntityState;
+          reasons: CanvasEntityConnectionDisabledReason[];
+          fixable: boolean;
+          requiresCallConnectionTo: CallableEntityState | null;
+          requiresCallConnectionToFrom: CallerEntityState | null;
+          nonAutofixableReasons: (CanvasEntityConnectionDisabledReason.VariableDeclarationCannotBeMovedToLowerScopeBecauseInstancesUsage | CanvasEntityConnectionDisabledReason.CannotChangeScopeBecauseItCallsOtherEntities | CanvasEntityConnectionDisabledReason.CannotChangeScopeBecauseItIsCalledByOtherEntities)[];
+      };
+  }
+
   export declare interface IContinueStatement extends ITerminationStatement, IContinueStatement_meta {
       type: EntityType.ContinueStatement;
       parent: ILoop;
@@ -25471,6 +25514,18 @@ export declare enum BaseValueDescriptorIds {
 
   export declare function modifyEditableAndDeletableDownstreamEntitiesFromGiven(entity: UserManagedEntityState, changeSet: ChangeSet, newValue: boolean, seenEntities?: Set<string>): void;
 
+  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;
+      }[];
+  };
+
   export declare const MUTABLE_META_PROPERTIES_EXPLANATION = "Some meta-data properties of entities can be changed after the initial creation, like 'name', 'description', etc...\nThese are called mutable meta-properties.";
 
   export declare const NESTED_PROPERTY_HEIGHT = 26;
@@ -30916,7 +30971,9 @@ export declare enum BaseValueDescriptorIds {
       reasons: CanvasEntityDisabledReason[];
   };
 
-  export declare function removeRedundantCallers(entity: CallableEntityState, changeSet: ChangeSet | null): ChangeSet | null;
+  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>;
 
   export declare function repeatList(list: unknown, count: unknown): any[];