@elyx-code/project-logic-tree 0.0.1

package/dist/tree/state/variable-instance/variable-instance.d.ts

@@ -0,0 +1,125 @@
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IVariableInstance, IVariableInstanceGenerationTarget, IVariableInstanceReference, IVariableInstanceShallowTransfer, IVariableInstanceTransfer, VariableInstanceTypesUnion } from '../../../../../../../../../src/definitions';
+import { ZodError } from 'zod';
+import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, EntityWithValueClass, PassThroughCallableEntityClass, UserManagedEntityStateFunctionality, ValueReadingEntityClass, ValueWritingEntityClass } from '../base';
+import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, PassThroughCallableEntityState, ValueReadingEntityState, ValueWritingEntityState } from '../types';
+import { ProjectState } from '../project';
+import { VariableInputMapState } from '../input-map';
+import { VariableOutputMapState } from '../output-map';
+import { InternalCallState } from '../internal-call';
+import { VariableDeclarationState } from '../variable-declaration';
+import { EntityError, EntityGenerationError } from '../error';
+import { PrimitiveValueState } from '../primitive-value';
+import { DataTypeState } from '../data-type';
+
+export declare class VariableInstanceState implements IVariableInstance, BaseState, UserManagedEntityStateFunctionality, ValueWritingEntityClass, ValueReadingEntityClass, BaseCanvasDraggableState, ChildEntityState, EntityWithValueClass, PassThroughCallableEntityClass, CallableEntityClass {
+    initialData: IVariableInstance | IVariableInstanceTransfer;
+    readonly id: EntityId;
+    version: EntityVersion;
+    x: number;
+    y: number;
+    readonly type: EntityType.VariableInstance;
+    writesValues: ValueReadingEntityState[];
+    readsValue: ValueWritingEntityState | null;
+    declaration: VariableDeclarationState;
+    inputs: VariableInputMapState[];
+    outputs: VariableOutputMapState[];
+    calledBySuccess: PassThroughCallableEntityState[];
+    calledByError: PassThroughCallableEntityState[];
+    calledByEntry: EntryPointEntityState[];
+    successCalls: CallableEntityState[];
+    errorCalls: CallableEntityState[];
+    internalCalls: InternalCallState[];
+    project: ProjectState;
+    errors: EntityError[];
+    parent: EntityWithLogicScopeState | ProjectState;
+    initialized: boolean;
+    constructor(initialVariableDeclarationData: IVariableInstance | IVariableInstanceTransfer, 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: IVariableInstanceGenerationTarget, parentProjectState: ProjectState): VariableInstanceState;
+    static validateGenerationTarget(data: IVariableInstanceGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        modifiedData: IVariableInstanceGenerationTarget;
+    };
+    validateGeneratedUpdate(data: Partial<IVariableInstanceGenerationTarget>): {
+        errors: EntityGenerationError[];
+        modifiedData: Partial<IVariableInstanceGenerationTarget>;
+    };
+    addSelfToProject(): VariableInstanceState;
+    get calledBy(): CallerEntityState[];
+    get usedInputs(): VariableInputMapState[];
+    get unusedInputs(): VariableInputMapState[];
+    get usedOutputs(): VariableOutputMapState[];
+    get unusedOutputs(): VariableOutputMapState[];
+    removeInput(input: VariableInputMapState): VariableInstanceState;
+    addInput(input: VariableInputMapState): VariableInstanceState;
+    addOutput(output: VariableOutputMapState): VariableInstanceState;
+    removeOutput(output: VariableOutputMapState): VariableInstanceState;
+    addSuccessCaller(caller: PassThroughCallableEntityState): VariableInstanceState;
+    addErrorCaller(caller: PassThroughCallableEntityState): VariableInstanceState;
+    addEntryCaller(caller: EntryPointEntityState): VariableInstanceState;
+    addErrorCall(call: CallableEntityState): VariableInstanceState;
+    addSuccessCall(call: CallableEntityState): VariableInstanceState;
+    removeCall(call: CallableEntityState): VariableInstanceState;
+    removeCaller(caller: CallerEntityState): VariableInstanceState;
+    addValueReader(entity: ValueReadingEntityState): VariableInstanceState;
+    setParent(parent: EntityWithLogicScopeState | ProjectState): VariableInstanceState;
+    initChildren(): VariableInstanceState;
+    setValueWriter(valueWriter: ValueWritingEntityState): VariableInstanceState;
+    removeValueReader(valueReader: ValueReadingEntityState): VariableInstanceState;
+    subscribe(): VariableInstanceState;
+    unsubscribe(): VariableInstanceState;
+    sync(data: Partial<IVariableInstance>): VariableInstanceState;
+    load(): Promise<VariableInstanceState>;
+    create(): Promise<VariableInstanceState>;
+    update(data: Partial<VariableInstanceTypesUnion>): Promise<VariableInstanceState>;
+    delete(): Promise<VariableInstanceState>;
+    remove({ ignoreUpstream, seenEntities, }?: {
+        ignoreUpstream: boolean;
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        removed: EntityState[];
+    };
+    restore({ seenEntities }?: {
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        self: VariableInstanceState;
+    };
+    toFlat(seenEntities?: Set<string>): EntityState[];
+    toFlatIds(seenEntities?: Set<string>): EntityId[];
+    toJSON(): IVariableInstanceTransfer;
+    toReference(): IVariableInstanceReference;
+    toShallowJSON(): IVariableInstanceShallowTransfer;
+    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toGenerationTarget(): IVariableInstanceGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    clearErrors(): VariableInstanceState;
+    validate(): {
+        success: boolean;
+        error: ZodError | null;
+        data: IVariableInstanceTransfer | null;
+    };
+    getErrors(): EntityError[];
+    getShallowErrors(): EntityError[];
+    getDefaultValue(): PrimitiveValueState | null;
+    clone(_?: EntryPointEntityState): VariableInstanceState;
+    addInternalCall(internalCall: InternalCallState): VariableInstanceState;
+    setDeclaration(declaration: VariableDeclarationState): VariableInstanceState;
+    generateUnusedInputs(): VariableInputMapState[];
+    generateUnusedOutputs(): VariableOutputMapState[];
+    getDataType(): DataTypeState | null;
+}
+export type VariableInstancePayloadUnion = VariableInstanceTypesUnion | VariableInstanceState;

package/dist/tree/utils/data-type.d.ts

@@ -0,0 +1,51 @@
+import { ArgumentDeclarationState, CustomEntityState, DataTypeState, EntityWithValueState, InputMapState, OutputMapState, PropertyState, ReturnDeclarationState, VariableDeclarationState, VariableInstanceState } from '../state';
+import { ActionDescriptorState } from '../state/action-descriptor';
+import { ValueDescriptorState } from '../state/value-descriptor';
+
+export declare function checkArePropertiesCompatibleAsDataType(sourceProperty: PropertyState, targetProperty: PropertyState): boolean;
+export declare function checkAreCustomEntitiesCompatibleAsDataType(sourceCustomEntity: CustomEntityState, targetCustomEntity: CustomEntityState): boolean;
+export declare enum DataTypeCompatibilityTypes {
+    BothUnconstrained = "both-unconstrained",
+    AConstraintBUnconstrained = "a-constraint-b-unconstrained",
+    BConstraintAUnconstrained = "b-constraint-a-unconstrained",
+    Same = "same",
+    AIsListBIsNot = "a-is-list-b-is-not",
+    BIsListAIsNot = "b-is-list-a-is-not",
+    AIsNullableBIsNot = "a-is-nullable-b-is-not",
+    BIsNullableAIsNot = "b-is-nullable-a-is-not",
+    AIsTemplateBIsNot = "a-is-template-b-is-not",
+    BIsTemplateAIsNot = "b-is-template-a-is-not",
+    BothUntyped = "both-untyped",
+    AIsUntypedBIsNot = "a-is-untyped-b-is-not",
+    BIsUntypedAIsNot = "b-is-untyped-a-is-not",
+    TypeEntityMismatch = "type-entity-mismatch",
+    SameCustomEntities = "same-custom-entities",
+    CompatibleCustomEntities = "compatible-custom-entities",
+    IncompatibleCustomEntities = "incompatible-custom-entities",
+    SamePrimitiveEntities = "same-primitive-entities",
+    IncompatiblePrimitiveEntities = "incompatible-primitive-entities",
+    SameBuiltInBaseEntities = "same-built-in-base-entities",
+    IncompatibleBuiltInBaseEntities = "incompatible-built-in-base-entities",
+    CheckUnknown = "check-unknown"
+}
+export interface IDataTypeCompatibility {
+    compatible: boolean;
+    type: DataTypeCompatibilityTypes;
+}
+export interface IDataTypeCompatible extends IDataTypeCompatibility {
+    compatible: true;
+    type: DataTypeCompatibilityTypes.BothUnconstrained | DataTypeCompatibilityTypes.AConstraintBUnconstrained | DataTypeCompatibilityTypes.BConstraintAUnconstrained | DataTypeCompatibilityTypes.Same | DataTypeCompatibilityTypes.BothUntyped | DataTypeCompatibilityTypes.AIsUntypedBIsNot | DataTypeCompatibilityTypes.BIsUntypedAIsNot | DataTypeCompatibilityTypes.SameCustomEntities | DataTypeCompatibilityTypes.CompatibleCustomEntities | DataTypeCompatibilityTypes.SamePrimitiveEntities | DataTypeCompatibilityTypes.SameBuiltInBaseEntities;
+}
+export interface IDataTypeIncompatibile extends IDataTypeCompatibility {
+    compatible: false;
+    type: DataTypeCompatibilityTypes.AIsListBIsNot | DataTypeCompatibilityTypes.BIsListAIsNot | DataTypeCompatibilityTypes.AIsNullableBIsNot | DataTypeCompatibilityTypes.BIsNullableAIsNot | DataTypeCompatibilityTypes.AIsTemplateBIsNot | DataTypeCompatibilityTypes.BIsTemplateAIsNot | DataTypeCompatibilityTypes.TypeEntityMismatch | DataTypeCompatibilityTypes.IncompatibleCustomEntities | DataTypeCompatibilityTypes.IncompatiblePrimitiveEntities | DataTypeCompatibilityTypes.IncompatibleBuiltInBaseEntities | DataTypeCompatibilityTypes.CheckUnknown;
+}
+export declare function checkAreDataTypesCompatible(dataTypeA: DataTypeState | null, dataTypeB: DataTypeState | null): IDataTypeCompatible | IDataTypeIncompatibile;
+export declare function generateExecutionDataType(entity: PropertyState | ArgumentDeclarationState | ReturnDeclarationState | VariableDeclarationState | ActionDescriptorState | ValueDescriptorState | DataTypeState): DataTypeState;
+export declare function inferArgumentDeclarationDataType(entity: ArgumentDeclarationState): DataTypeState | null;
+export declare function inferInputMapDataType(entity: InputMapState): DataTypeState | null;
+export declare function inferVariableInstanceDataType(entity: VariableInstanceState): DataTypeState | null;
+export declare function inferVariableDeclarationDataType(entity: VariableDeclarationState): DataTypeState | null;
+export declare function inferOutputMapDataType(entity: OutputMapState): DataTypeState | null;
+export declare function inferDataType(entity: EntityWithValueState): DataTypeState | null;
+export declare function resolveDataType(entity: EntityWithValueState): DataTypeState | null;

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

@@ -0,0 +1,158 @@
+import { BaseEntityNames, ElementGenerationTarget, ElementShallowTransfer, ElementTransfer, EntityType, Element, IGenericReference, ValueReadingEntityTypesUnion } from '../../../../../../../../src/definitions';
+import { DraggableCallableEntityState, CanvasEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, DraggableExecutableEntityState, DraggablePassThroughCallableEntityState, ValueReadingEntityState, ValueWritingEntityState, EntityWithValueState, VariableState, BuiltInBaseEntityState, TerminationState, InstalledProjectState, ExecutableEntityState, ValueDescriptorState, CallableEntityState, CallerEntityState, PrimitiveEntityState } from '../state';
+import { FunctionCallState } from '../state/function-call';
+import { InputMapState } from '../state/input-map';
+import { VariableDeclarationState } from '../state/variable-declaration';
+import { ArgumentDeclarationState } from '../state/argument-declaration';
+import { ReturnDeclarationState } from '../state/return-declaration';
+import { OutputMapState } from '../state/output-map';
+import { ConditionState } from '../state/condition';
+import { ReturnStatementState } from '../state/return-statement';
+import { FunctionDeclarationState } from '../state/function-declaration';
+import { ProjectState } from '../state/project/project';
+import { PropertyState } from '../state/property';
+import { OperationState } from '../state/operation';
+import { CustomEntityState } from '../state/custom-entity';
+import { VariableInstanceState } from '../state/variable-instance';
+import { LoopState } from '../state/loop';
+import { SearchState } from '../state/search';
+
+export declare function flattenCanvasAncestorsUntil(entity: CanvasEntityState, until: CanvasEntityState): {
+    list: CanvasEntityState[];
+    last: CanvasEntityState | null;
+};
+export declare function getCommonChildren(entityA: CanvasEntityState, entityB: CanvasEntityState, seenEntities?: Set<string>): CanvasEntityState[];
+export declare function checkIsBranchDependentButNotDirectlyOnBranch(branchA: CanvasEntityState, branchB: CanvasEntityState): boolean;
+export declare function checkIsBranchDependentOnBranch(branchA: CanvasEntityState, branchB: CanvasEntityState): boolean;
+export declare function getParentEntryPoint(entity: EntityState): EntryPointEntityState | null;
+export declare function getCommonAncestor(entityA: EntityState, entityB: EntityState): EntityState | null;
+export declare function getParentCanvasEntity(entity: EntityState): CanvasEntityState | null;
+export declare function getChildrenEntityWithValues(entity: CanvasEntityState): EntityWithValueState[];
+export declare function sortChildrenEntitiesBasedOnExecutionDependencies(entity: CanvasEntityState): CanvasEntityState[];
+export declare function sortCallsBasedOnExecutionDependencies(calls: DraggableCallableEntityState[]): DraggableCallableEntityState[];
+export declare function groupCallsBasedOnParallelizableExecution(calls: DraggableCallableEntityState[]): DraggableCallableEntityState[][];
+export declare function getParentCanvasEntities(entities: EntityState[]): CanvasEntityState[];
+export declare function getCalls(entity: DraggableExecutableEntityState): DraggableCallableEntityState[];
+export declare function resolveFirstCallsSecond(first: DraggableExecutableEntityState, second: DraggableCallableEntityState): boolean;
+export declare function getWrites(entity: ValueWritingEntityState): ValueReadingEntityState[];
+export declare function resolveFirstWritesSecond(first: ValueWritingEntityState, second: ValueReadingEntityState): boolean;
+export declare function getVariableFromInputMapping(input: InputMapState): VariableState | null;
+export declare function getLinkedEntitiesFromArgumentDeclaration(argumentDeclaration: ArgumentDeclarationState): ValueReadingEntityState[];
+export declare function getVariablesFromInputMaps(args?: InputMapState[]): VariableState[];
+export declare function getVariablesFromArgumentDeclarations(args?: ArgumentDeclarationState[]): VariableState[];
+export declare function getVariablesFromReturnDeclarations(returnDecls?: ReturnDeclarationState[]): VariableState[];
+export declare function getVariableFromReturnVariablePointer(entity: VariableState | InputMapState): VariableState | null;
+export declare function getVariablesFromOutputMapping(returnedElement: OutputMapState): VariableState[];
+export declare function getVariablesFromOutputMaps(returnedElements?: OutputMapState[]): VariableState[];
+export declare function flattenElementCalls(element: CallerEntityState): CallableEntityState[];
+export declare function flattenVariableWrites(variable: VariableState, seenVariables?: Set<string>): VariableState[];
+export declare function flattenVariableReads(variable: VariableState, seenVariables?: Set<string>): VariableState[];
+export declare function flattenVariables(element: CanvasEntityState, seenVariables?: Set<string>): VariableState[];
+export declare function flattenDerivedCanvasEntities(entity: CanvasEntityState, seenEntities?: Set<string>): CanvasEntityState[];
+export declare function flattenCalls(entities: CallableEntityState[]): CallableEntityState[];
+export declare function flattenProjectElements(project: ProjectState): EntityState[];
+export declare function findReferenceToSelfInList(element: EntityState, elements: EntityState[]): EntityState[];
+export declare function findReferencesToSelfInProject(element: EntityState): EntityState[];
+export declare function getRelatedCanvasElementsOnTheLeft(entity: CanvasEntityState): CanvasEntityState[];
+export declare function getEntityArgumentDeclarations(entity: ExecutableEntityState): (ArgumentDeclarationState | ValueDescriptorState)[];
+export declare function getUsedArgFromDeclaration(argumentDeclaration: ArgumentDeclarationState, entity: ConditionState | FunctionCallState | OperationState): InputMapState | null;
+export declare function getEntityInputMaps(entity: DraggablePassThroughCallableEntityState): InputMapState[];
+export declare function getEntityReturnDeclarations(entity: TerminationState | FunctionCallState | OperationState | SearchState): (ReturnDeclarationState | ValueDescriptorState)[];
+export declare function getUsedReturnFromDeclaration(returnDeclaration: ReturnDeclarationState, entity: ConditionState | FunctionCallState | OperationState): OutputMapState | null;
+export declare function getEntityOutputMaps(entity: DraggablePassThroughCallableEntityState): OutputMapState[];
+export declare function getCanvasEntityDerivedFromValueReadingEntity(valueReadingEntity: ValueReadingEntityState): CanvasEntityState | null;
+export declare function getCanvasEntitiesDerivedFromInternalCalls(entity: VariableState): CanvasEntityState[];
+export declare function getCanvasEntitiesDerivedFromWrites(valueWrittingEntity: ValueWritingEntityState): CanvasEntityState[];
+export declare function filterOutDuplicateEntities(entities: (EntityState | Element | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget)[]): (Element | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget | EntityState)[];
+export declare function getRelatedCanvasElementsOnTheRight(entity: CanvasEntityState | ProjectState, respectCollapse?: boolean): CanvasEntityState[];
+export declare function flattenRelatedCanvasElementsOnTheRight(entity: CanvasEntityState | ProjectState, respectCollapse?: boolean): CanvasEntityState[];
+export declare function flattenRelatedCanvasElementsOnTheLeft(entity: CanvasEntityState): CanvasEntityState[];
+export declare function flattenCustomEntityImplementionTypes(entity: CustomEntityState): (BaseEntityNames | EntityType.CustomEntity)[];
+export declare function flattenCustomEntityExtensionTypes(entity: CustomEntityState): (BaseEntityNames | EntityType.CustomEntity)[];
+export declare function flattenCustomEntityExtensions(entity: CustomEntityState): (BuiltInBaseEntityState | CustomEntityState)[];
+export declare function flattenCustomEntityImplementations(entity: CustomEntityState): (BuiltInBaseEntityState | CustomEntityState)[];
+export declare function flattenCustomEntityExtensionAndImplementationTypes(entity: CustomEntityState): (BaseEntityNames | EntityType.CustomEntity)[];
+export declare function getLowestPersistedEntityImplementation(entity: CustomEntityState): CustomEntityState;
+export declare function getExtendedBuiltInEntity(entity: CustomEntityState): BuiltInBaseEntityState | null;
+export declare function getImplementedBuiltInEntity(entity: CustomEntityState): BuiltInBaseEntityState | null;
+export declare function getExtendedCustomEntity(entity: CustomEntityState): CustomEntityState | null;
+export declare function getBaseBuiltInEntities(entity: CustomEntityState): BuiltInBaseEntityState[];
+export declare function getIsInteractive(entity: CustomEntityState | BuiltInBaseEntityState | PrimitiveEntityState): boolean;
+export declare function checkIsGlobalVariable(entity: VariableDeclarationState): boolean;
+export declare function checkIsGloballyDeclared(entity: ConditionState | FunctionCallState | OperationState | VariableDeclarationState | VariableInstanceState | FunctionCallState | LoopState | SearchState): boolean;
+export declare function checkIsDetachedBranch(entity: CanvasEntityState): boolean;
+export declare function checkIsDetachedBranchShallow(entity: CanvasEntityState): boolean;
+export declare function getHeadIfPartOfDetachedBranch(entity: CanvasEntityState, levelsChecked?: number): CanvasEntityState | null;
+export declare function flattenDetachedBranch(entity: CanvasEntityState): CanvasEntityState[];
+export declare function checkIsMethod(entity: EntityState): boolean;
+export declare function mergeListOfEntities(oldErrors: EntityState[], newErrors: EntityState[]): EntityState[];
+export declare function getPrototypeByType(type: EntityType): typeof OutputMapState | typeof InputMapState | typeof OperationState | typeof InstalledProjectState | typeof ConditionState | typeof SearchState | typeof ReturnDeclarationState | typeof ProjectState | typeof CustomEntityState | typeof PropertyState | typeof FunctionDeclarationState | typeof FunctionCallState | typeof VariableDeclarationState | typeof VariableInstanceState | typeof ArgumentDeclarationState | typeof LoopState | typeof ReturnStatementState | typeof BuiltInBaseEntityState | null;
+export declare function getScopeOwner(entity: EntityState | Element | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer, project: ProjectState): EntityWithLogicScopeState | ProjectState | null;
+export declare function getRootEntryPointScopeOwner(entity: EntityState | Element | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer, project: ProjectState): EntityWithLogicScopeState | null;
+export declare function checkIsNestedScope(parent: EntityWithLogicScopeState | ProjectState, child: EntityWithLogicScopeState | ProjectState, project: ProjectState): boolean;
+export declare enum ScopeCompatibilityType {
+    SameBothLocal = "same-both-local",
+    AInB = "a-in-b",
+    BInA = "b-in-a",
+    ParallelInCommonParent = "parallel-in-common-parent",
+    ParallelInProject = "parallel-in-project",
+    AIsGlobalBIsNot = "a-is-global-b-is-not",
+    BIsGlobalAIsNot = "b-is-global-a-is-not",
+    SameBothGlobal = "same-both-global"
+}
+export interface IScopeCompatibility {
+    compatible: boolean;
+    type: ScopeCompatibilityType;
+    commonAncestorScope: EntityWithLogicScopeState | ProjectState;
+}
+export interface ICompatibleSameBothLocalScope extends IScopeCompatibility {
+    compatible: true;
+    type: ScopeCompatibilityType.SameBothLocal;
+}
+export interface ICompatibleSameBothGlobalScope extends IScopeCompatibility {
+    compatible: true;
+    type: ScopeCompatibilityType.SameBothGlobal;
+}
+export interface ICompatibleAInBScope extends IScopeCompatibility {
+    compatible: true;
+    type: ScopeCompatibilityType.AInB;
+}
+export interface ICompatibleBInAScope extends IScopeCompatibility {
+    compatible: true;
+    type: ScopeCompatibilityType.BInA;
+}
+export interface IIncompatibleParallelInProjectScope extends IScopeCompatibility {
+    compatible: false;
+    type: ScopeCompatibilityType.ParallelInProject;
+}
+export interface IIncompatibleParallelInCommonParentScope extends IScopeCompatibility {
+    compatible: false;
+    type: ScopeCompatibilityType.ParallelInCommonParent;
+}
+export interface IIncompatibleAIsGlobalBIsNotScope extends IScopeCompatibility {
+    compatible: false;
+    type: ScopeCompatibilityType.AIsGlobalBIsNot;
+}
+export interface IIncompatibleBIsGlobalAIsNotScope extends IScopeCompatibility {
+    compatible: false;
+    type: ScopeCompatibilityType.BIsGlobalAIsNot;
+}
+export type ScopeCompatibility = ICompatibleSameBothLocalScope | ICompatibleSameBothGlobalScope | ICompatibleAInBScope | ICompatibleBInAScope | IIncompatibleParallelInProjectScope | IIncompatibleParallelInCommonParentScope | IIncompatibleAIsGlobalBIsNotScope | IIncompatibleBIsGlobalAIsNotScope;
+export type CompatibleScope = ICompatibleSameBothLocalScope | ICompatibleSameBothGlobalScope | ICompatibleAInBScope | ICompatibleBInAScope;
+export type IncompatibleScope = IIncompatibleParallelInProjectScope | IIncompatibleParallelInCommonParentScope | IIncompatibleAIsGlobalBIsNotScope | IIncompatibleBIsGlobalAIsNotScope;
+export declare function checkScopeCompatibility(entityA: EntityState | Element | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer, entityB: EntityState | Element | ElementTransfer | ElementGenerationTarget | ElementShallowTransfer, project: ProjectState): ScopeCompatibility;
+export declare function getHighestScope(scopeOwnerA: EntityWithLogicScopeState, scopeOwnerB: EntityWithLogicScopeState, project: ProjectState): EntityWithLogicScopeState | null;
+export declare function getDeepestScope(scopeOwners: EntityWithLogicScopeState[]): EntityWithLogicScopeState | null;
+export declare function toEntityState(entity: string | EntityState | IGenericReference | Element | ElementTransfer | ElementShallowTransfer | ElementGenerationTarget, project: ProjectState): EntityState | null;
+export declare function getBuiltInEntityOwner(entity: EntityState): EntityState | null;
+export declare function updateValueReader(data: Partial<ValueReadingEntityTypesUnion>, self: ValueReadingEntityState): ValueReadingEntityState;
+export declare function checkIsCallableEntityReachable(entity: CallableEntityState): {
+    reachable: boolean;
+    entryPoint: EntryPointEntityState;
+    blocks: {
+        blockedByCaller: CallerEntityState;
+        blockedByCalling: TerminationState;
+    }[];
+};
+export declare function checkIsCanvasEntity(entity: EntityState): boolean;
+export declare function mapActionDescriptorToTypeItRepresents(entity: EntityState): EntityType;

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

@@ -0,0 +1,32 @@
+import { BaseEntityNames, ElementGenerationTarget, ElementShallowTransfer, ElementTransfer, IArgumentDeclarationGenerationTarget, IArgumentDeclarationShallowTransfer, IArgumentDeclarationTransfer, ICustomEntityGenerationTarget, ICustomEntityShallowTransfer, ICustomEntityTransfer, IFunctionDeclarationGenerationTarget, IFunctionDeclarationShallowTransfer, IFunctionDeclarationTransfer, IPropertyGenerationTarget, IPropertyShallowTransfer, IPropertyTransfer, IReturnDeclarationGenerationTarget, IReturnDeclarationShallowTransfer, IReturnDeclarationTransfer, IVariableDeclarationGenerationTarget, IVariableDeclarationShallowTransfer, IVariableDeclarationTransfer, PrimitiveTypes } from '../../../../../../../../src/definitions';
+import { ArgumentDeclarationState, BuiltInBaseEntityState, ConditionState, CustomEntityState, DataTypeState, EntityPayloadUnion, EntityWithValueState, FunctionDeclarationState, ActionDescriptorState, ProjectState, PropertyState, ReturnDeclarationState, SearchState, VariableDeclarationState, VariableInstanceState, ValueDescriptorState } from '../state';
+import { EntityGenerationError } from '../state/error';
+
+export declare function toCamelCase(str: string): string;
+export declare function toPascalCase(str: string): string;
+export declare function toKebabCase(str: string): string;
+export declare function toLowerCaseKebabCase(str: string): string;
+export declare function resolveVariableDeclarationDataTypeLabel(declaration: VariableDeclarationState | ReturnDeclarationState | ArgumentDeclarationState | ValueDescriptorState | PropertyState, isInput?: boolean): string;
+export declare function resolveVariableInstanceDataTypeLabel(varInstance: VariableInstanceState): string;
+export declare function resolveVariableDataTypeLabel(variable: VariableDeclarationState | ReturnDeclarationState | ArgumentDeclarationState | VariableInstanceState): string;
+export declare function resolveDataTypeLabel(dataType: DataTypeState): string;
+export declare function resolvePropertyDataTypeLabel(property: PropertyState): string;
+export declare function resolveEntityDataTypeLabel(entity: PropertyState | EntityWithValueState | ValueDescriptorState): string;
+export declare function resolveConditionOperatorLabel(condition: ConditionState): "and" | "or" | "is equal to" | "is not equal to" | "is greater than" | "is greater than or equal to" | "is less than" | "is less than or equal to" | "is empty" | "is not empty" | undefined;
+export declare function resolveBaseEntityName(baseEntities: BaseEntityNames[]): string;
+export declare function resolveBuiltInBaseEntityDataTypeLabel(entity: BuiltInBaseEntityState): string;
+export declare function resolveCustomEntityDataTypeLabel(entity: CustomEntityState): 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 validateCustomEntityName(entity: CustomEntityState | ICustomEntityGenerationTarget | ICustomEntityShallowTransfer | ICustomEntityTransfer, 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 validateReturnDeclarationName(entity: ReturnDeclarationState | IReturnDeclarationGenerationTarget | IReturnDeclarationShallowTransfer | IReturnDeclarationTransfer, project: ProjectState): EntityGenerationError[];
+export declare function validateName(entity: ElementGenerationTarget | ElementShallowTransfer | ElementTransfer, project: ProjectState): EntityGenerationError[];

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

@@ -0,0 +1,4 @@
+import { Element, ElementGenerationTarget, ElementShallowTransfer, ElementTransfer, IGenericReference } from '../../../../../../../../src/definitions';
+import { EntityState } from '../state';
+
+export declare function getReferenceEntityId(reference: string | IGenericReference | EntityState | Element | ElementShallowTransfer | ElementTransfer | ElementGenerationTarget): string | null;

package/dist/tree/utils/shared-data-structure-entity.d.ts

@@ -0,0 +1,26 @@
+import { BuiltInBaseEntityState, CustomEntityState, EntityState } from '../state';
+import { EntityGenerationError } from '../state/error';
+
+export declare function handleBeforeEntityImplementationSideEffects(self: CustomEntityState | BuiltInBaseEntityState): {
+    newEntities: EntityState[];
+};
+export declare function handleAfterEntityImplementationSideEffects(implemented: CustomEntityState): {
+    newEntities: EntityState[];
+};
+export declare function implement(self: CustomEntityState | BuiltInBaseEntityState, newEntityName: string, newId?: string): {
+    errors: [];
+    implemented: CustomEntityState;
+    entitiesChanges: {
+        new: EntityState[];
+        updated: EntityState[];
+        deleted: EntityState[];
+    };
+} | {
+    errors: [EntityGenerationError, ...EntityGenerationError[]];
+    implemented: null;
+    entitiesChanges: {
+        new: [];
+        updated: [];
+        deleted: [];
+    };
+};

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

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

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

@@ -0,0 +1,7 @@
+import { ElementGenerationTarget, EntityType } from '../../../../../../../../src/definitions';
+import { default as short } from 'short-uuid';
+import { ProjectState } from '../state';
+
+export declare const UUID: short.Translator;
+export declare function createSemanticId(entityName: string, entityType: EntityType, project: ProjectState): string;
+export declare function suggestNewIdForEntity(generatedEntity: ElementGenerationTarget, projectState: ProjectState): string;

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

@@ -0,0 +1,5 @@
+import { EntityWithLogicScopeState, ProjectState, 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[];

package/package.json

@@ -0,0 +1,65 @@
+{
+	"name": "@elyx-code/project-logic-tree",
+	"version": "0.0.1",
+	"author": "Sergio Herrero",
+	"license": "UNLICENSED",
+	"description": "An installable module which contains the type definitions and ephemeral state management for a projects' logic tree data structure",
+	"type": "module",
+	"files": [
+		"dist/*"
+	],
+	"main": "./dist/index.umd.cjs",
+	"module": "./dist/index.js",
+	"types": "dist/index.d.ts",
+	"scripts": {
+		"dev": "vite",
+		"build": "tsc && vite build",
+		"test": "jest --verbose"
+	},
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"require": "./dist/index.umd.cjs",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"dependencies": {
+		"@elyx-code/definitions": "^0.0.7956",
+		"axios": "^1.6.5",
+		"short-uuid": "^4.2.2",
+		"underscore": "^1.13.7",
+		"zod": "^3.22.4",
+		"zod-validation-error": "^3.3.0"
+	},
+	"devDependencies": {
+		"@types/jest": "^27.4.1",
+		"@types/node": "^20.5.0",
+		"@types/underscore": "^1.11.15",
+		"jest": "^27.5.1",
+		"ts-jest": "^27.1.4",
+		"typescript": "^5.0.2",
+		"vite": "^4.4.5",
+		"vite-plugin-dts": "^3.5.2"
+	},
+	"jest": {
+		"preset": "ts-jest/presets/js-with-ts",
+		"testEnvironment": "jsdom",
+		"moduleNameMapper": {
+			"^.+\\.(scss|css|less)$": "<rootDir>/__mocks__/defaultModuleMock.js",
+			"\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$": "<rootDir>/__mocks__/fileMock.js"
+		}
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/elyx-code/project-logic-tree.git"
+	},
+	"keywords": [
+		"types",
+		"typings",
+		"mock"
+	],
+	"bugs": {
+		"url": "https://github.com/elyx-code/project-logic-tree/issues"
+	},
+	"homepage": "https://github.com/elyx-code/project-logic-tree#readme"
+}