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

package/dist/index.d.ts

@@ -10706,10 +10706,19 @@ export declare enum BaseValueDescriptorIds {
 
  export declare const cryptoPBKDF2SaltEncodingDT: IDataTypeTransfer;
 
+ /**
+  * Type of entities that can be used/referenced in the 'entity' field of a data type.
+  */
+ export declare const DATA_TYPE_ENTITY_OPTION_TYPES: EntityType[];
+
  export declare const DATA_TYPE_OPERATIONS: {
      [key: string]: IActionDescriptorTransfer;
  };
 
+ export declare const DATA_TYPE_PARENT_TYPES: EntityType[];
+
+ export declare const DATA_TYPE_USER_MANAGED_PARENT_TYPES: EntityType[];
+
  declare class DataSource implements IDataSource, ISearchNode {
      owner: SearchStatementState;
      entity: DefinitionEntityState | null;
@@ -12459,6 +12468,11 @@ export declare enum BaseValueDescriptorIds {
 
  export declare function enrichFromKnownEntities(entity: ElementTransfer | Element_2 | ElementShallowTransfer | IGenericReference | EntityId, allKnownEntities: Record<EntityId, Element_2 | ElementTransfer | ElementShallowTransfer>): Element_2 | ElementTransfer | ElementShallowTransfer | null;
 
+ /**
+  * Entity types that have a 'dataType' field.
+  */
+ export declare const ENTITIES_WITH_DATA_TYPES: EntityType[];
+
  export declare const ENTITIES_WITH_VALUES_EXPLANATION: string;
 
  export declare function entitiesToUniqueCanvasEntities(entities: EntityState[], filterOut?: string[]): CanvasEntityState[];
@@ -12555,6 +12569,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 +15108,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 +15427,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 */
@@ -15420,6 +15491,13 @@ export declare enum BaseValueDescriptorIds {
      }[];
  };
 
+ export declare function getAllAvailableValueReaderEntities(project: ProjectState): {
+     explanations: {
+         id: GenerationExplanationIds.AllAvailableValueReaderEntities | GenerationExplanationIds.EntitiesWithValues;
+         message: string;
+     }[];
+ };
+
  export declare function getAllBuiltInEntityIds(): Set<EntityId>;
 
  export declare function getAllBuiltInEntityIdsAsync(options?: YieldOptions): Promise<Set<EntityId>>;
@@ -15432,6 +15510,13 @@ export declare enum BaseValueDescriptorIds {
 
  export declare function getAllValueReadingChildren(entity: CanvasEntityState | InternalCallState): ValueReadingEntityState[];
 
+ export declare function getAllValueWriterEntities(project: ProjectState): {
+     explanations: {
+         id: GenerationExplanationIds.AllAvailableValueWriterEntities | GenerationExplanationIds.EntitiesWithValues;
+         message: string;
+     }[];
+ };
+
  export declare function getAllValueWritingChildren(entity: CanvasEntityState | InternalCallState): ValueWritingEntityState[];
 
  export declare function getAllValueWritingEntities(project: ProjectState, options?: YieldOptions): Promise<ValueWritingEntityState[]>;
@@ -15440,6 +15525,20 @@ export declare enum BaseValueDescriptorIds {
 
  export declare function getAllVariablesInScope(project: ProjectState, variableDeclarations: VariableDeclarationState[], targetEntity?: UserManagedEntityState): VariableDeclarationState[];
 
+ export declare function getAvailableValueReadersForGivenWritter(project: ProjectState, valueWriterEntity: ValueWritingEntityState): Promise<{
+     explanations: {
+         id: GenerationExplanationIds.AvailableValueReadersForGivenWriter | GenerationExplanationIds.EntitiesWithValues;
+         message: string;
+     }[];
+ }>;
+
+ export declare function getAvailableValueWritersForGivenReader(project: ProjectState, valueReaderEntity: ValueReadingEntityState): Promise<{
+     explanations: {
+         id: GenerationExplanationIds.AvailableValueWritersForGivenReader | GenerationExplanationIds.EntitiesWithValues;
+         message: string;
+     }[];
+ }>;
+
  export declare function getBaseBuiltInEntities(entity: DefinitionEntityState | BuiltInBaseEntityState): BuiltInBaseEntityState[];
 
  export declare function getBaseBuiltInNameFromIntegrationName(integrationName: ExternalIntegrationNames): BaseEntityNames | null;
@@ -18647,6 +18746,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 +22683,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"
   }
@@ -30466,7 +30577,7 @@ export declare enum BaseValueDescriptorIds {
 
   export declare const PROPERTY_IMPLEMENTATION_AND_EXTENSION_AUTO_ENRICHMENT_EXPLANATION = "When a 'property' entity is added to a 'definition-entity', the system will automatically enrich the property based on the parent definition-entity's implemented and extended entities.\nThis means that if a property is required, the parent 'definition-entity' will have auto-generated it. If a manually added property can fit into a parent, it will be auto-enriched with any required 'implementation' or 'extension' references, and the data-type will be recalculated or constrained based on said extensions and implementations.\nThis means that manually adding an 'extends' field to a new property is not necessary, and only specific, non-required 'implements' references need to be added manually if needed.";
 
-  export declare const PROPERTY_NOT_VALUE_READER_WRITER_EXPLANATION = "A property entity, is neither a value reading, or a value writting entity, but they are often confused with one.\nA 'property' can have a default value through its nested 'data-type' entity.\nThe 'property' entity only represents the data field in the declaration, and it can't write or read values.\nWhen a 'definition-entity' is instantiated as a variable, any writes or reads to its properties are done through 'input-map's and 'output-map's.";
+  export declare const PROPERTY_NOT_VALUE_READER_WRITER_EXPLANATION = "A property entity, is neither a value reading, or a value writting entity, but they are often confused with one.\nBecause a 'property' can have a default value.\nThe 'property' entity only represents the data field in the declaration, and it can't write or read values.\nWhen a 'definition-entity' is instantiated as a variable, any writes or reads to its properties are done through 'input-map's and 'output-map's.";
 
   export declare enum PropertyDependencyField {
       PropertyImplements = "property-implements-field",
@@ -30911,6 +31022,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;