@elyx-code/project-logic-tree 0.0.1

package/dist/tree/state/error.d.ts

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+import { EntityState } from './types';
+
+export declare enum EntityErrorSeverity {
+    Error = "error",
+    Warning = "warning"
+}
+export declare enum SharedEntityErrorCode {
+    InvalidObjectStructure = "invalid-object-structure",
+    NameNotUniqueInScope = "name-not-unique-in-scope",
+    EmptyName = "empty-name",
+    MissingCaller = "missing-caller",
+    PropertyOverwrite = "property-overwrite",
+    MethodOverwrite = "method-overwrite",
+    NoOverlapWithImplementedSignature = "no-overlap-with-implemented-signature",
+    ReaderWriterIncompatibleDataType = "reader-writer-incompatible-data-type",
+    UnreachableEntity = "unreachable-entity"
+}
+export declare enum EntityGenerationErrorCode {
+    RootReference = "root-reference",
+    ReferencedEntityNotFound = "referenced-entity-not-found",
+    EntityIdNotUnique = "entity-id-not-unique",
+    BuiltInEntityGenerated = "built-in-entity-generated",
+    BuiltInEntityUpdated = "built-in-entity-updated",
+    BuiltInEntityDeleted = "built-in-entity-deleted",
+    UnknownEntityType = "unknown-entity-type",
+    MissingTypeProperty = "missing-type-property",
+    MissingIdProperty = "missing-id-property",
+    BuiltInEntityParent = "built-in-entity-parent",
+    InvalidBuiltInEntityReference = "invalid-built-in-entity-reference",
+    RecommendedImplementAbstractEntityAction = "recommended-implement-abstract-entity-action",
+    RecommendedImplementOperationAction = "recommended-implement-operation-action",
+    RecommendedImplementFunctionCallAction = "recommended-implement-function-call-action",
+    RecommendedImplementVariableDeclarationAction = "recommended-implement-variable-declaration-action",
+    RecommendedImplementVariableInstanceAction = "recommended-implement-variable-instance-action",
+    RecommendedImplementConditionAction = "recommended-implement-condition-action",
+    InvalidReferenceObjectStructure = "invalid-reference-object-structure",
+    ContainsSingleButShouldBeReferenceList = "contains-single-but-should-be-reference-list",
+    ContainsListButShouldReferenceSingle = "contains-list-but-should-reference-single",
+    InvalidParentReference = "invalid-parent-reference",
+    InvalidImplementsReference = "invalid-implements-reference",
+    InvalidExtendsReference = "invalid-extends-reference",
+    InvalidGenerationActionPayload = "invalid-generation-action-payload",
+    InvalidReference = "invalid-reference",
+    InvalidInternalCallParentDeclarationRelation = "invalid-internal-call-parent-declaration-relation",
+    InvalidInternalCallParentRelation = "invalid-internal-call-parent-relation",
+    InvalidUpdateEntityOperation = "invalid-update-entity-operation",
+    NewEntityWouldOverriteExisting = "new-entity-would-overrite-existing",
+    InvalidDownstreamPropertyOverride = "invalid-downstream-property-override",
+    UnrecognizedProperty = "unrecognized-property",
+    SelfReference = "self-reference",
+    DuplicateReference = "duplicate-reference",
+    CallerWithIncompatibleScope = "caller-with-incompatible-scope",
+    InvalidFunctionDeclarationForFunctionCall = "invalid-function-declaration-for-function-call",
+    InvalidInputMapDeclaration = "invalid-input-map-declaration",
+    InvalidActionDescriptorForOperation = "invalid-action-descriptor-for-operation",
+    InvalidActionDescriptorForCondition = "invalid-action-descriptor-for-condition",
+    InvalidActionDescriptorForLoop = "invalid-action-descriptor-for-loop",
+    InvalidInmutablePropertyOverride = "invalid-inmutable-property-override",
+    OutputOverwrite = "output-overwrite",
+    InputOverwrite = "input-overwrite",
+    IncompatibleScope = "incompatible-scope",
+    InvalidParentUpdate = "invalid-parent-update",
+    NonInteractiveEntityReferenced = "non-interactive-entity-referenced",
+    InvalidParentRelationType = "invalid-parent-relation-type"
+}
+export declare enum EntityInstanceErrorCode {
+    ScopeWithoutLogic = "scope-without-logic",
+    ExtendingAbstractEntity = "extending-abstract-entity",
+    ImplementingNonAbstractEntity = "implementing-non-abstract-entity",
+    AbstractEntityWithNonAbstractMethods = "abstract-entity-with-non-abstract-methods",
+    AbstractEntityWithNonAbstractProperties = "abstract-entity-with-non-abstract-properties",
+    StaticEntityWithNonStaticProperties = "static-entity-with-non-static-properties",
+    NonStaticPropertyInStaticEntity = "non-static-property-in-static-entity",
+    AbstractPropertyInNonAbstractEntity = "abstract-property-in-non-abstract-entity",
+    AbstractMethodInNonAbstractEntity = "abstract-method-in-non-abstract-entity",
+    IncorrectEntityImplementation = "incorrect-entity-implementation",
+    IncorrectMethodImplementation = "incorrect-method-implementation",
+    IncorrectPropertyImplementation = "incorrect-property-implementation",
+    PropertyImplementsNonAbstact = "property-implements-non-abstract",
+    NonStaticPropertyImplementsStatic = "non-static-property-implements-static",
+    StaticPropertyImplementsNonStatic = "static-property-implements-non-static",
+    PropertyImplementsIncompatibleType = "property-implements-incompatible-type",
+    MissingPropertyImplementation = "missing-property-implementation",
+    MissingMethodImplementation = "missing-method-implementation",
+    NoProperties = "no-properties",
+    ReadingFromIncompatibleType = "reading-from-incompatible-type",
+    WritingToIncompatibleType = "writing-to-incompatible-type",
+    InvalidPropertiesCombination = "invalid-properties-combination",
+    DisconnectedCallableEntity = "disconnected-callable-entity"
+}
+export type EntityErrorCode = SharedEntityErrorCode | EntityGenerationErrorCode | EntityInstanceErrorCode;
+export interface IEntityGenerationError {
+    id: string;
+    message: string;
+    issue: z.ZodIssue | null;
+    severity: EntityErrorSeverity;
+    code: SharedEntityErrorCode | EntityGenerationErrorCode;
+}
+export interface IEntityError {
+    id: string;
+    message: string;
+    issue: z.ZodIssue | null;
+    severity: EntityErrorSeverity;
+    code: SharedEntityErrorCode | EntityInstanceErrorCode;
+    entity: EntityState;
+}
+export declare class EntityGenerationError implements IEntityGenerationError {
+    id: string;
+    message: string;
+    issue: z.ZodIssue | null;
+    severity: EntityErrorSeverity;
+    code: SharedEntityErrorCode | EntityGenerationErrorCode;
+    constructor(error: IEntityGenerationError);
+    toEntityError(entity: EntityState): EntityError | null;
+}
+export declare class EntityError implements IEntityError {
+    id: string;
+    message: string;
+    issue: z.ZodIssue | null;
+    severity: EntityErrorSeverity;
+    code: SharedEntityErrorCode | EntityInstanceErrorCode;
+    entity: EntityState;
+    constructor(error: IEntityError);
+    clone(): EntityError;
+}
+export declare function filterOutDuplicateErrors(errors: (EntityGenerationError | EntityError)[]): EntityGenerationError[] | EntityError[];
+export declare function createEntityError(error: IEntityError): {
+    new: boolean;
+    error: EntityError;
+};
+export declare function mergeEntityErrorsList(oldErrors: EntityError[], newErrors: EntityError[]): EntityError[];
+export declare function updateErrorsList(oldErrors: EntityError[], newErrors: EntityError[]): EntityError[];

package/dist/tree/state/function-call/function-call.d.ts

@@ -0,0 +1,111 @@
+import { EntityId, EntityType, EntityVersion, IFunctionCall, IFunctionCallTransfer, IFunctionCallReference, IFunctionCallShallowTransfer, ElementShallowTransfer, IFunctionCallGenerationTarget, ElementGenerationTarget, FunctionCallTypesUnion } from '../../../../../../../../../src/definitions';
+import { ZodError } from 'zod';
+import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass, UserManagedEntityStateFunctionality } from '../base';
+import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, PassThroughCallableEntityState, ValueReadingEntityState } from '../types';
+import { FunctionDeclarationState } from '../function-declaration';
+import { ActionInputMapState } from '../input-map';
+import { ActionOutputMapState } from '../output-map';
+import { ProjectState } from '../project/project';
+import { EntityError, EntityGenerationError } from '../../state/error';
+
+export declare class FunctionCallState implements IFunctionCall, BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
+    initialData: IFunctionCall | IFunctionCallTransfer;
+    readonly id: EntityId;
+    version: EntityVersion;
+    x: number;
+    y: number;
+    readonly type: EntityType.FunctionCall;
+    successCalls: CallableEntityState[];
+    errorCalls: CallableEntityState[];
+    process: ActionOutputMapState | null;
+    declaration: FunctionDeclarationState;
+    inputs: ActionInputMapState[];
+    outputs: ActionOutputMapState[];
+    calledBySuccess: PassThroughCallableEntityState[];
+    calledByError: PassThroughCallableEntityState[];
+    calledByEntry: EntryPointEntityState[];
+    error: ActionOutputMapState | null;
+    parent: EntityWithLogicScopeState | ProjectState;
+    errors: EntityError[];
+    project: ProjectState;
+    initialized: boolean;
+    constructor(initialFunctionCallData: IFunctionCall | IFunctionCallTransfer, parentProjectState: ProjectState);
+    static MUTABLE_BASE_PROPERTIES: string[];
+    static INMUTABLE_BASE_PROPERTIES: string[];
+    static BASE_PROPERTIES: string[];
+    static MUTABLE_META_PROPERTIES: string[];
+    static INMUTABLE_META_PROPERTIES: string[];
+    static META_PROPERTIES: string[];
+    static MUTABLE_UPSTREAM_PROPERTIES: string[];
+    static INMUTABLE_UPSTREAM_PROPERTIES: string[];
+    static UPSTREAM_PROPERTIES: string[];
+    static MUTABLE_DOWNSTREAM_PROPERTIES: string[];
+    static INMUTABLE_DOWNSTREAM_PROPERTIES: string[];
+    static DOWNSTREAM_PROPERTIES: string[];
+    static PROPERTIES: string[];
+    static fromGenerationTarget(data: IFunctionCallGenerationTarget, parentProjectState: ProjectState): FunctionCallState;
+    static validateGenerationTarget(data: IFunctionCallGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        modifiedData: IFunctionCallGenerationTarget;
+    };
+    validateGeneratedUpdate(data: Partial<IFunctionCallGenerationTarget>): {
+        errors: EntityGenerationError[];
+        modifiedData: Partial<IFunctionCallGenerationTarget>;
+    };
+    addSelfToProject(): FunctionCallState;
+    get calledBy(): CallerEntityState[];
+    removeInput(input: ActionInputMapState): FunctionCallState;
+    addInput(input: ActionInputMapState): FunctionCallState;
+    addOutput(output: ActionOutputMapState): FunctionCallState;
+    removeOutput(output: ActionOutputMapState): FunctionCallState;
+    addValueReader(entity: ValueReadingEntityState): FunctionCallState;
+    removeValueReader(valueReader: ValueReadingEntityState): FunctionCallState;
+    addSuccessCaller(caller: PassThroughCallableEntityState): FunctionCallState;
+    addErrorCaller(caller: PassThroughCallableEntityState): FunctionCallState;
+    addEntryCaller(caller: EntryPointEntityState): FunctionCallState;
+    addErrorCall(call: CallableEntityState): FunctionCallState;
+    addSuccessCall(call: CallableEntityState): FunctionCallState;
+    removeCall(call: CallableEntityState): FunctionCallState;
+    removeCaller(caller: CallerEntityState): FunctionCallState;
+    setParent(parent: EntityWithLogicScopeState | ProjectState): FunctionCallState;
+    initChildren(): FunctionCallState;
+    initOutputs(): FunctionCallState;
+    subscribe(): FunctionCallState;
+    unsubscribe(): FunctionCallState;
+    sync(data: Partial<IFunctionCall>): FunctionCallState;
+    load(): Promise<FunctionCallState>;
+    create(): Promise<FunctionCallState>;
+    update(_: Partial<FunctionCallTypesUnion>): Promise<FunctionCallState>;
+    delete(): Promise<FunctionCallState>;
+    remove({ ignoreUpstream, seenEntities, }?: {
+        ignoreUpstream: boolean;
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        removed: EntityState[];
+    };
+    restore({ seenEntities }?: {
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        self: FunctionCallState;
+    };
+    toFlat(seenEntities?: Set<string>): EntityState[];
+    toFlatIds(seenEntities?: Set<string>): EntityId[];
+    toJSON(): IFunctionCallTransfer;
+    toReference(): IFunctionCallReference;
+    toShallowJSON(): IFunctionCallShallowTransfer;
+    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toGenerationTarget(): IFunctionCallGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    clearErrors(): FunctionCallState;
+    validate(): {
+        success: boolean;
+        error: ZodError | null;
+        data: IFunctionCallTransfer | null;
+    };
+    getErrors(): EntityError[];
+    getShallowErrors(): EntityError[];
+    clone(_?: EntryPointEntityState): FunctionCallState;
+}
+export type FunctionCallPayloadUnion = FunctionCallState | FunctionCallTypesUnion;

package/dist/tree/state/function-call/index.d.ts

@@ -0,0 +1 @@
+export * from './function-call';

package/dist/tree/state/function-call/validation/logic-validation.d.ts

@@ -0,0 +1,4 @@
+import { EntityError } from '../../error';
+import { FunctionCallState } from '../function-call';
+
+export declare function validate(self: FunctionCallState): EntityError[];