@elyx-code/project-logic-tree 0.0.6819 → 0.0.6821

package/dist/index.d.ts

@@ -12555,6 +12555,7 @@ export declare enum BaseValueDescriptorIds {
      RecommendedImplementFunctionCallAction = "recommended-implement-function-call-action",
      RecommendedImplementVariableDeclarationAction = "recommended-implement-variable-declaration-action",
      RecommendedImplementVariableInstanceAction = "recommended-implement-variable-instance-action",
+     RecommendedImplementInternalCallAction = "recommended-implement-internal-call-action",
      RecommendedImplementConditionAction = "recommended-implement-condition-action",
      InvalidReferenceObjectStructure = "invalid-reference-object-structure",
      ContainsSingleButShouldBeReferenceList = "contains-single-but-should-be-reference-list",
@@ -15093,6 +15094,49 @@ export declare enum BaseValueDescriptorIds {
 
  export declare function generateActionExample(actionName: string, properties: Record<string, string>): string;
 
+ export declare function generateAllAvailableMethodsThatCanBeCalledAsInternalCallsExplanation(project: ProjectState): {
+     explanations: {
+         id: GenerationExplanationIds.AllAvailableMethodsThatCanBeCalledAsInternalCalls | GenerationExplanationIds.ReasonsForMethodsNotAvailableAsInternalCalls;
+         message: string;
+     }[];
+ };
+
+ /**
+  * Add explanation about all available methods on this variable's data-type entity.
+  * And if none, all the available methods on existing variables in the project that could be used.
+  * And if none, then all the available methods in the project that could be implemented as internal calls.
+  *
+  * If the given declaration id does exist in the given variable's data-type entity, skip.
+  *
+  * @param {string} declarationId
+  * @param {VariableState | null} variableEntityState
+  * @returns {{
+          *  explanations: {
+              *    id: GenerationExplanationIds.AvailableInternalCallsForGivenVariablesDataTypeEntity
+              *      | GenerationExplanationIds.AvailableInternalCallsOfAnyDeclarationInAllInstanciatedVariablesDataTypeEntities
+              *      | GenerationExplanationIds.AllAvailableMethodsThatCanBeCalledAsInternalCalls
+              *      | GenerationExplanationIds.ReasonsForMethodsNotAvailableAsInternalCalls
+              *      | GenerationExplanationIds.NonAvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables
+              *      | GenerationExplanationIds.AvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables
+              *      | GenerationExplanationIds.InternalCalls;
+              *    message: string;
+              *  }[];
+          * }}
+  */
+ export declare function generateAvailableInternalCallsExplanation(project: ProjectState, declarationId: string | null, variableEntityState: VariableState | null): {
+     explanations: {
+         id: GenerationExplanationIds.AvailableInternalCallsForGivenVariablesDataTypeEntity | GenerationExplanationIds.AvailableInternalCallsOfAnyDeclarationInAllInstanciatedVariablesDataTypeEntities | GenerationExplanationIds.AllAvailableMethodsThatCanBeCalledAsInternalCalls | GenerationExplanationIds.ReasonsForMethodsNotAvailableAsInternalCalls | GenerationExplanationIds.NonAvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables | GenerationExplanationIds.AvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables | GenerationExplanationIds.InternalCalls;
+         message: string;
+     }[];
+ };
+
+ export declare function generateAvailableInternalCallsOfAnyDeclarationInAllInstanciatedVariablesDataTypeEntitiesExplanation(project: ProjectState): {
+     explanations: {
+         id: GenerationExplanationIds.AvailableInternalCallsOfAnyDeclarationInAllInstanciatedVariablesDataTypeEntities;
+         message: string;
+     }[];
+ };
+
  export declare function generateCaughtErrorOutputLogLines(entity: PassThroughCallableEntityWithOutputsState, options?: IPrintEntityOptions & {
      prefix?: string;
  }): {
@@ -15369,7 +15413,20 @@ export declare enum BaseValueDescriptorIds {
      OutputMapsAutogeneration = "output-maps-autogeneration-explanation",
      AvailableOutputMapsForGivenParentCallableEntity = "available-output-maps-for-given-parent-callable-entity-explanation",
      InputMapsAutogeneration = "input-maps-autogeneration-explanation",
-     AvailableInputMapsForGivenParentCallableEntity = "available-input-maps-for-given-parent-callable-entity-explanation"
+     InternalCallsAutogeneration = "internal-calls-autogeneration-explanation",
+     AvailableInputMapsForGivenParentCallableEntity = "available-input-maps-for-given-parent-callable-entity-explanation",
+     AvailableInternalCallsForGivenVariablesDataTypeEntity = "available-internal-calls-for-given-variables-data-type-entity-explanation",
+     NonAvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables = "non-available-internal-calls-with-same-declaration-in-existing-instanciated-variables-explanation",
+     AvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables = "available-internal-calls-with-same-declaration-in-existing-instanciated-variables-explanation",
+     AvailableInternalCallsOfAnyDeclarationInAllInstanciatedVariablesDataTypeEntities = "available-internal-calls-of-any-declaration-in-all-instanciated-variables-data-type-entities-explanation",
+     AllAvailableMethodsThatCanBeCalledAsInternalCalls = "all-available-methods-that-can-be-called-as-internal-calls",
+     InternalCalls = "internal-calls-explanation",
+     ReasonsForMethodsNotAvailableAsInternalCalls = "reasons-for-methods-not-available-as-internal-calls-explanation",
+     AllNonInteractiveDefinitionEntities = "all-non-interactive-definition-entities-explanation",
+     AllStaticAndAbstractDefinitionEntities = "all-static-and-abstract-definition-entities-explanation",
+     AllStaticNonAbstractDefinitionEntities = "all-static-non-abstract-definition-entities-explanation",
+     AllAbstractNonStaticDefinitionEntities = "all-abstract-non-static-definition-entities-explanation",
+     AllInstanciatableDefinitionEntities = "all-instantiatable-definition-entities-explanation"
  }
 
  /** lodash-like get(obj, path, defaultValue) with precise "missing" detection */
@@ -18647,6 +18704,14 @@ export declare enum BaseValueDescriptorIds {
 
  export declare function getIntegrationIdFromEntity(entity: DefinitionEntityState | BuiltInBaseEntityState | ActionDescriptorState | OperationState): ExternalIntegrationNames | null;
 
+ export declare function getIsGivenDeclarationIdAvailableInAnInstanciatedVarAndExplanation(declarationId: string, project: ProjectState): {
+     explanations: {
+         id: GenerationExplanationIds.NonAvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables | GenerationExplanationIds.AvailableInternalCallsWithSameDeclarationInExistingInstanciatedVariables;
+         message: string;
+     }[];
+     available: boolean;
+ };
+
  export declare function getIsInteractive(entity: DefinitionEntityState | BuiltInBaseEntityState | PrimitiveEntityState | PropertyState | InputMapState | OutputMapState): boolean;
 
  /**
@@ -22576,6 +22641,10 @@ export declare enum BaseValueDescriptorIds {
   }
   export { installedProjectValidation }
 
+  export declare const INTERNAL_CALLS_AUTOGENERATION_EXPLANATION = "Internal calls are automatically generated for any method of an applicable definition-entity that is the 'entity' of a data-type of a variable-declaration. So they never need to be created manually.\nTo use an internal call, it is almost always the only correct way, to create a dedicated variable-instance for it, with the 'implement_internal_call' generation action, which will create and instance and wire the call all in once and avoiding generation conflics.";
+
+  export declare const INTERNAL_CALLS_EXPLANATION = "An internal call is a callable entity type that can be called on a variable-instance to trigger the logic of a method (function-declaration in a definition-entity) of its data-type 'entity'.\nInternal calls are equivalent to method calls in other programing languages like Javascript, where you need a class instance initialized with the right state, then you call the method on it.\nIn our case, first we need a 'variable-declaration' with a data-type that has its 'entity' field pointing to a 'definition-entity' that contains a 'function-declaration' method called somewhere earlier in the same scopes' callstack.\nThis variable-declaration acts as the initialization of the class. Only then we can use a SEPARATE variable-instance to call the internal-call on.\nThis is equivalent to calling 'new' on a class to create an instance in Javascript, then calling a method on that instance in the next step. The internal call will have access to the state of the variable-declaration.";
+
   export declare enum InternalCallDependencyField {
       Declaration = "declaration"
   }
@@ -30911,6 +30980,8 @@ export declare enum BaseValueDescriptorIds {
 
   export declare function readValueFromWriter(entity: ValueReadingEntityState, context: IValueResolutionContext, onlyDefault?: boolean): IDynamicValue | null;
 
+  export declare const REASONS_FOR_METHODS_NOT_AVAILABLE_AS_INTERNAL_CALLS_EXPLANATION = "Not all methods of a definition-entity are available as internal calls. For a method to be available as an internal call its parent definition-entity needs to be the 'entity' of a data-type of a variable. It needs to belong to an 'interactive' definition-entity. It needs to not be part of an abstract definition-entity.";
+
   export declare function rebaseStack<T = any>(undoableStackValueIndex: number, history: T[], newItem: T): number;
 
   export declare function recursivelyMakeAllEditableAndDeletableFromGiven(entity: UserManagedEntityState, changeSet: ChangeSet | null): void;