@elyx-code/project-logic-tree 0.0.6996 → 0.0.7000

package/dist/definitions/types/return.d.ts

@@ -0,0 +1,103 @@
+import { EntityWithLogicScope, EntityWithLogicScopeReference, EntityType, IBaseCanvasDraggable, ICalledEntity, ICalledEntityTransfer, IChildEntity, IChildEntityTransfer, IValueReadingEntity, IValueReadingEntityTransfer, ILoopReference, ILoop, IValueReadingEntityShallowTransfer, IChildEntityShallowTransfer, ICalledEntityShallowTransfer, IChildEntityGenerationTarget, ICalledEntityGenerationTarget, IValueReadingEntityGenerationTarget, EntityId, PassThroughCallableEntity, PassThroughCallableEntityTransfer, PassThroughCallableEntityReference, EntryPointEntity, EntryPointEntityTransfer, EntryPointEntityReference, IInputMap, IInputMapTransfer, IInputMapReference, ValueWritingEntity, IDataTypeTransfer, ILiteralValue, ILiteralValueTransfer, IDataType, ILiteralValueReference, IDataTypeReference } from '.';
+
+export interface ITerminationStatement_meta extends IBaseCanvasDraggable {
+    type: EntityType.ReturnStatement | EntityType.BreakStatement | EntityType.ContinueStatement;
+}
+export interface ITerminationStatementTransfer extends ITerminationStatement_meta, IChildEntityTransfer, ICalledEntityTransfer, IValueReadingEntityTransfer {
+    outputs: (IInputMap | IInputMapTransfer)[];
+    calledBySuccess: (PassThroughCallableEntity | PassThroughCallableEntityTransfer | PassThroughCallableEntityReference)[];
+    calledByError: (PassThroughCallableEntity | PassThroughCallableEntityTransfer | PassThroughCallableEntityReference)[];
+    calledByEntry: (EntryPointEntity | EntryPointEntityTransfer | EntryPointEntityReference)[];
+    defaultValue: ILiteralValue | ILiteralValueTransfer | null;
+    dataType: IDataType | IDataTypeTransfer | null;
+    parent: EntityWithLogicScope | EntityWithLogicScopeReference;
+    throws: IInputMap | IInputMapTransfer | null;
+}
+export interface ITerminationStatementGenerationTarget extends IChildEntityGenerationTarget, ICalledEntityGenerationTarget, IValueReadingEntityGenerationTarget {
+    id: EntityId;
+    type: EntityType.ReturnStatement | EntityType.BreakStatement | EntityType.ContinueStatement;
+    calledBySuccess: EntityId[];
+    calledByError: EntityId[];
+    calledByEntry: EntityId[];
+    parent: EntityId;
+}
+export interface ITerminationStatementShallowTransfer extends ITerminationStatement_meta, IChildEntityShallowTransfer, ICalledEntityShallowTransfer, IValueReadingEntityShallowTransfer {
+    outputs: IInputMapReference[];
+    calledBySuccess: PassThroughCallableEntityReference[];
+    calledByError: PassThroughCallableEntityReference[];
+    calledByEntry: EntryPointEntityReference[];
+    defaultValue: ILiteralValueReference | null;
+    dataType: IDataTypeReference | null;
+    parent: EntityWithLogicScopeReference;
+    throws: IInputMapReference | null;
+}
+export interface ITerminationStatement extends ITerminationStatementTransfer, IChildEntity, ICalledEntity, IValueReadingEntity {
+    outputs: IInputMap[];
+    readsValue: ValueWritingEntity | null;
+    calledBySuccess: PassThroughCallableEntity[];
+    calledByError: PassThroughCallableEntity[];
+    calledByEntry: EntryPointEntity[];
+    defaultValue: ILiteralValue | null;
+    dataType: IDataType | null;
+    parent: EntityWithLogicScope;
+    throws: IInputMap | null;
+}
+export interface IReturnStatement_meta extends ITerminationStatement_meta {
+    type: EntityType.ReturnStatement;
+}
+export interface IReturnStatementTransfer extends ITerminationStatementTransfer, IReturnStatement_meta {
+    type: EntityType.ReturnStatement;
+    parent: EntryPointEntity | EntryPointEntityReference;
+}
+export interface IReturnStatementGenerationTarget extends ITerminationStatementGenerationTarget {
+    type: EntityType.ReturnStatement;
+}
+export interface IReturnStatementShallowTransfer extends ITerminationStatementShallowTransfer, IReturnStatement_meta {
+    type: EntityType.ReturnStatement;
+    parent: EntryPointEntityReference;
+}
+export interface IReturnStatement extends ITerminationStatement, IReturnStatement_meta {
+    type: EntityType.ReturnStatement;
+    parent: EntryPointEntity;
+}
+export interface IContinueStatement_meta extends ITerminationStatement_meta {
+    type: EntityType.ContinueStatement;
+}
+export interface IContinueStatementTransfer extends ITerminationStatementTransfer, IContinueStatement_meta {
+    type: EntityType.ContinueStatement;
+    parent: ILoop | ILoopReference;
+}
+export interface IContinueStatementGenerationTarget extends ITerminationStatementGenerationTarget {
+    type: EntityType.ContinueStatement;
+    parent: EntityId;
+}
+export interface IContinueStatementShallowTransfer extends ITerminationStatementShallowTransfer, IContinueStatement_meta {
+    type: EntityType.ContinueStatement;
+    parent: ILoopReference;
+}
+export interface IContinueStatement extends ITerminationStatement, IContinueStatement_meta {
+    type: EntityType.ContinueStatement;
+    parent: ILoop;
+}
+export interface IBreakStatement_meta extends ITerminationStatement_meta {
+    type: EntityType.BreakStatement;
+}
+export interface IBreakStatementTransfer extends ITerminationStatementTransfer, IBreakStatement_meta {
+    type: EntityType.BreakStatement;
+    parent: ILoop | ILoopReference;
+}
+export interface IBreakStatementGenerationTarget extends ITerminationStatementGenerationTarget {
+    type: EntityType.BreakStatement;
+    parent: EntityId;
+}
+export interface IBreakStatementShallowTransfer extends ITerminationStatementShallowTransfer, IBreakStatement_meta {
+    type: EntityType.BreakStatement;
+    parent: ILoopReference;
+}
+export interface IBreakStatement extends ITerminationStatement, IBreakStatement_meta {
+    type: EntityType.BreakStatement;
+    parent: ILoop;
+}
+export type ReturnStatementTypesUnion = IReturnStatement | IReturnStatementTransfer | IReturnStatementShallowTransfer | IReturnStatementGenerationTarget;
+export type ContinueStatementTypesUnion = IContinueStatement | IContinueStatementTransfer | IContinueStatementShallowTransfer | IContinueStatementGenerationTarget;
+export type BreakStatementTypesUnion = IBreakStatement | IBreakStatementTransfer | IBreakStatementShallowTransfer | IBreakStatementGenerationTarget;

package/dist/definitions/types/search.d.ts

@@ -0,0 +1,66 @@
+import { CallableEntity, CallableEntityTransfer, EntityWithLogicScope, EntityWithLogicScopeReference, IProject, IProjectReference, IActionOutputMap, IActionOutputMapTransfer, IActionInputMap, EntityType, ICalledEntity, ICalledEntityTransfer, IChildEntity, IChildEntityTransfer, IValueDescriptor, IActionInputMapTransfer, IValueDescriptorTransfer, IBaseCanvasDraggable, ICalledEntityShallowTransfer, IChildEntityShallowTransfer, IValueDescriptorReference, IInputMapReference, IOutputMapReference, CallableEntityReference, IChildEntityGenerationTarget, ICalledEntityGenerationTarget, EntityId, EntryPointEntityReference, EntryPointEntityTransfer, EntryPointEntity, PassThroughCallableEntityReference, PassThroughCallableEntityTransfer, PassThroughCallableEntity, IBaseActionCall_meta, IBaseActionCallTransfer, IBaseActionCallShallowTransfer, IBaseActionCall, ValueReadingEntity, IDataType, IDataTypeTransfer, IDataTypeReference } from '.';
+
+export interface ISearch_meta extends IBaseCanvasDraggable, IBaseActionCall_meta {
+    type: EntityType.Search;
+    name: string;
+    description: string | null;
+    query: string;
+    catchesError: boolean;
+}
+export interface ISearchTransfer extends ISearch_meta, IChildEntityTransfer, ICalledEntityTransfer, Omit<IBaseActionCallTransfer, 'declaration'> {
+    type: EntityType.Search;
+    inputsDeclarations: (IValueDescriptor | IValueDescriptorTransfer)[];
+    inputs: (IActionInputMap | IActionInputMapTransfer)[];
+    dataType: IDataType | IDataTypeTransfer | null;
+    outputs: (IActionOutputMap | IActionOutputMapTransfer)[];
+    successCalls: (CallableEntity | CallableEntityTransfer)[];
+    errorCalls: (CallableEntity | CallableEntityTransfer)[];
+    calledBySuccess: (PassThroughCallableEntity | PassThroughCallableEntityTransfer | PassThroughCallableEntityReference)[];
+    calledByError: (PassThroughCallableEntity | PassThroughCallableEntityTransfer | PassThroughCallableEntityReference)[];
+    calledByEntry: (EntryPointEntity | EntryPointEntityTransfer | EntryPointEntityReference)[];
+    parent: EntityWithLogicScope | EntityWithLogicScopeReference | IProject | IProjectReference;
+    error: IActionOutputMap | IActionOutputMapTransfer | null;
+}
+export interface ISearchGenerationTarget extends IChildEntityGenerationTarget, ICalledEntityGenerationTarget {
+    id: EntityId;
+    type: EntityType.Search;
+    name: string;
+    description: string | null;
+    calledBySuccess: EntityId[];
+    calledByError: EntityId[];
+    calledByEntry: EntityId[];
+    query: string;
+    parent?: EntityId;
+    catchesError?: boolean;
+}
+export interface ISearchShallowTransfer extends ISearch_meta, IChildEntityShallowTransfer, ICalledEntityShallowTransfer, Omit<IBaseActionCallShallowTransfer, 'declaration'> {
+    type: EntityType.Search;
+    inputsDeclarations: IValueDescriptorReference[];
+    inputs: IInputMapReference[];
+    dataType: IDataTypeReference | null;
+    outputs: IOutputMapReference[];
+    successCalls: CallableEntityReference[];
+    errorCalls: CallableEntityReference[];
+    calledBySuccess: PassThroughCallableEntityReference[];
+    calledByError: PassThroughCallableEntityReference[];
+    calledByEntry: EntryPointEntityReference[];
+    query: string;
+    parent: EntityWithLogicScopeReference | IProjectReference;
+    error: IOutputMapReference | null;
+}
+export interface ISearch extends ISearchTransfer, IChildEntity, ICalledEntity, Omit<IBaseActionCall, 'declaration'> {
+    type: EntityType.Search;
+    successCalls: CallableEntity[];
+    errorCalls: CallableEntity[];
+    writesValues: ValueReadingEntity[];
+    inputsDeclarations: IValueDescriptor[];
+    inputs: IActionInputMap[];
+    dataType: IDataType | null;
+    outputs: IActionOutputMap[];
+    calledBySuccess: PassThroughCallableEntity[];
+    calledByError: PassThroughCallableEntity[];
+    calledByEntry: EntryPointEntity[];
+    parent: EntityWithLogicScope | IProject;
+    error: IActionOutputMap | null;
+}
+export type SearchTypesUnion = ISearch | ISearchTransfer | ISearchShallowTransfer | ISearchGenerationTarget;

package/dist/definitions/types/variable.d.ts

@@ -0,0 +1,150 @@
+import { EntityWithLogicScope, EntityWithLogicScopeReference, IProject, IProjectReference, IVariableInputMap, IVariableInputMapTransfer, IVariableOutputMap, IVariableOutputMapTransfer, EntityType, IBaseCanvasDraggable, IBaseVariable, IBaseVariableTransfer, IChildEntity, IChildEntityTransfer, IValueReadingEntity, IValueReadingEntityTransfer, IValueWritingEntity, IValueWritingEntityTransfer, CallableEntity, CallableEntityTransfer, IVariableDeclarationReference, IBaseActionCallTransfer, IFunctionDeclaration, IActionInputMap, IActionOutputMap, IVariableInstanceReference, IInternalCallReference, IFunctionDeclarationReference, IFunctionDeclarationTransfer, IBaseActionCallShallowTransfer, IValueWritingEntityShallowTransfer, IBaseVariableShallowTransfer, IChildEntityShallowTransfer, IValueReadingEntityShallowTransfer, IInputMapReference, IOutputMapReference, CallableEntityReference, IChildEntityGenerationTarget, IValueReadingEntityGenerationTarget, IValueWritingEntityGenerationTarget, IBaseVariableGenerationTarget, IBaseActionCallGenerationTarget, EntityId, PassThroughCallableEntity, EntryPointEntity, PassThroughCallableEntityReference, EntryPointEntityReference, PassThroughCallableEntityTransfer, EntryPointEntityTransfer, ILiteralValue, ILiteralValueTransfer, ILiteralValueReference, IBaseActionCall_meta, IBaseVariable_meta, IActionOutputMapTransfer, IActionDescriptor, IActionDescriptorTransfer, IActionDescriptorReference } from '.';
+
+export interface IInternalCall_meta extends IBaseActionCall_meta {
+    type: EntityType.InternalCall;
+    index: number;
+    catchesError: boolean;
+}
+export interface IInternalCallTransfer extends IBaseActionCallTransfer, IInternalCall_meta {
+    type: EntityType.InternalCall;
+    declaration: IFunctionDeclarationTransfer | IFunctionDeclarationReference | IActionDescriptor | IActionDescriptorTransfer;
+    parent: IVariableDeclaration | IVariableDeclarationTransfer | IVariableDeclarationReference | IVariableInstance | IVariableInstanceTransfer | IVariableInstanceReference;
+}
+export interface IInternalCallGenerationTarget extends IBaseActionCallGenerationTarget {
+    id: EntityId;
+    type: EntityType.InternalCall;
+    declaration: EntityId;
+    parent: EntityId;
+    catchesError?: boolean;
+}
+export interface IInternalCallShallowTransfer extends IInternalCall_meta, IBaseActionCallShallowTransfer {
+    type: EntityType.InternalCall;
+    declaration: IFunctionDeclarationReference | IActionDescriptorReference;
+    parent: IVariableDeclarationReference | IVariableInstanceReference;
+}
+export interface IInternalCall extends IInternalCallTransfer {
+    declaration: IFunctionDeclaration | IActionDescriptor;
+    inputs: IActionInputMap[];
+    outputs: IActionOutputMap[];
+    successCalls: CallableEntity[];
+    errorCalls: CallableEntity[];
+    calledBySuccess: PassThroughCallableEntity[];
+    calledByError: PassThroughCallableEntity[];
+    calledByEntry: EntryPointEntity[];
+    parent: IVariableDeclaration | IVariableInstance;
+    error: IActionOutputMap | null;
+}
+export interface IVariableDeclaration_meta extends IBaseCanvasDraggable, IBaseVariable_meta {
+    type: EntityType.VariableDeclaration;
+    catchesError: boolean;
+}
+export interface IVariableDeclarationTransfer extends IVariableDeclaration_meta, IBaseVariableTransfer, IChildEntityTransfer, IValueReadingEntityTransfer, IValueWritingEntityTransfer {
+    type: EntityType.VariableDeclaration;
+    inputs: IVariableInputMapTransfer[];
+    outputs: IVariableOutputMapTransfer[];
+    successCalls: (CallableEntity | CallableEntityTransfer)[];
+    errorCalls: (CallableEntity | CallableEntityTransfer)[];
+    internalCalls: (IInternalCall | IInternalCallTransfer | IInternalCallReference)[];
+    calledBySuccess: (PassThroughCallableEntity | PassThroughCallableEntityTransfer | PassThroughCallableEntityReference)[];
+    calledByError: (PassThroughCallableEntity | PassThroughCallableEntityTransfer | PassThroughCallableEntityReference)[];
+    calledByEntry: (EntryPointEntity | EntryPointEntityTransfer | EntryPointEntityReference)[];
+    parent: EntityWithLogicScope | IProject | EntityWithLogicScopeReference | IProjectReference;
+    error: IActionOutputMap | IActionOutputMapTransfer | null;
+}
+export interface IVariableDeclarationGenerationTarget extends IBaseVariableGenerationTarget, IChildEntityGenerationTarget, IValueReadingEntityGenerationTarget, IValueWritingEntityGenerationTarget {
+    id: EntityId;
+    type: EntityType.VariableDeclaration;
+    calledBySuccess: EntityId[];
+    calledByError: EntityId[];
+    calledByEntry: EntityId[];
+    parent?: EntityId;
+    catchesError?: boolean;
+}
+export interface IVariableDeclarationShallowTransfer extends IVariableDeclaration_meta, IBaseVariableShallowTransfer, IChildEntityShallowTransfer, IValueReadingEntityShallowTransfer, IValueWritingEntityShallowTransfer {
+    type: EntityType.VariableDeclaration;
+    inputs: IInputMapReference[];
+    outputs: IOutputMapReference[];
+    successCalls: CallableEntityReference[];
+    errorCalls: CallableEntityReference[];
+    internalCalls: IInternalCallReference[];
+    calledBySuccess: PassThroughCallableEntityReference[];
+    calledByError: PassThroughCallableEntityReference[];
+    calledByEntry: EntryPointEntityReference[];
+    parent: EntityWithLogicScopeReference | IProjectReference;
+    error: IOutputMapReference | null;
+}
+export interface IVariableDeclaration extends IChildEntity, IVariableDeclaration_meta, IBaseVariable, IValueReadingEntity, IValueWritingEntity {
+    type: EntityType.VariableDeclaration;
+    inputs: IVariableInputMap[];
+    outputs: IVariableOutputMap[];
+    successCalls: CallableEntity[];
+    errorCalls: CallableEntity[];
+    internalCalls: IInternalCall[];
+    calledBySuccess: PassThroughCallableEntity[];
+    calledByError: PassThroughCallableEntity[];
+    calledByEntry: EntryPointEntity[];
+    parent: EntityWithLogicScope | IProject;
+    error: IActionOutputMap | null;
+}
+export interface IVariableInstance_meta extends IBaseCanvasDraggable {
+    type: EntityType.VariableInstance;
+    catchesError: boolean;
+}
+export interface IVariableInstanceTransfer extends IVariableInstance_meta, IChildEntityTransfer, IValueReadingEntityTransfer, IValueWritingEntityTransfer {
+    type: EntityType.VariableInstance;
+    defaultValue: ILiteralValue | ILiteralValueTransfer | null;
+    declaration: IVariableDeclaration | IVariableDeclarationTransfer | IVariableDeclarationReference;
+    inputs: IVariableInputMapTransfer[];
+    outputs: IVariableOutputMapTransfer[];
+    successCalls: (CallableEntity | CallableEntityTransfer)[];
+    errorCalls: (CallableEntity | CallableEntityTransfer)[];
+    internalCalls: (IInternalCall | IInternalCallTransfer | IInternalCallReference)[];
+    calledBySuccess: (PassThroughCallableEntity | PassThroughCallableEntityTransfer | PassThroughCallableEntityReference)[];
+    calledByError: (PassThroughCallableEntity | PassThroughCallableEntityTransfer | PassThroughCallableEntityReference)[];
+    calledByEntry: (EntryPointEntity | EntryPointEntityTransfer | EntryPointEntityReference)[];
+    parent: EntityWithLogicScope | IProject | EntityWithLogicScopeReference | IProjectReference;
+    error: IActionOutputMap | IActionOutputMapTransfer | null;
+}
+export interface IVariableInstanceGenerationTarget extends IChildEntityGenerationTarget, IValueReadingEntityGenerationTarget, IValueWritingEntityGenerationTarget {
+    id: EntityId;
+    type: EntityType.VariableInstance;
+    declaration: EntityId;
+    calledBySuccess: EntityId[];
+    calledByError: EntityId[];
+    calledByEntry: EntityId[];
+    parent?: EntityId;
+    catchesError?: boolean;
+}
+export interface IVariableInstanceShallowTransfer extends IVariableInstance_meta, IChildEntityShallowTransfer, IValueReadingEntityShallowTransfer, IValueWritingEntityShallowTransfer {
+    type: EntityType.VariableInstance;
+    defaultValue: ILiteralValueReference | null;
+    declaration: IVariableDeclarationReference;
+    inputs: IInputMapReference[];
+    outputs: IOutputMapReference[];
+    successCalls: CallableEntityReference[];
+    errorCalls: CallableEntityReference[];
+    internalCalls: IInternalCallReference[];
+    calledBySuccess: PassThroughCallableEntityReference[];
+    calledByError: PassThroughCallableEntityReference[];
+    calledByEntry: EntryPointEntityReference[];
+    parent: EntityWithLogicScopeReference | IProjectReference;
+    error: IOutputMapReference | null;
+}
+export interface IVariableInstance extends IChildEntity, IVariableInstance_meta, IValueReadingEntity, IValueWritingEntity {
+    type: EntityType.VariableInstance;
+    defaultValue: ILiteralValue | null;
+    inputs: IVariableInputMap[];
+    outputs: IVariableOutputMap[];
+    successCalls: CallableEntity[];
+    errorCalls: CallableEntity[];
+    internalCalls: IInternalCall[];
+    calledBySuccess: PassThroughCallableEntity[];
+    calledByError: PassThroughCallableEntity[];
+    calledByEntry: EntryPointEntity[];
+    declaration: IVariableDeclaration;
+    parent: EntityWithLogicScope | IProject;
+    error: IActionOutputMap | null;
+}
+export type InternalCallTypesUnion = IInternalCall | IInternalCallTransfer | IInternalCallReference | IInternalCallGenerationTarget;
+export type VariableDeclarationTypesUnion = IVariableDeclaration | IVariableDeclarationTransfer | IVariableDeclarationReference | IVariableDeclarationGenerationTarget;
+export type VariableInstanceTypesUnion = IVariableInstance | IVariableInstanceTransfer | IVariableInstanceReference | IVariableInstanceGenerationTarget;

package/dist/editor/area.d.ts

@@ -0,0 +1,75 @@
+import { ChangeSet, CanvasEntityState, ProjectState } from '../tree';
+
+export interface ICoordinates {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+}
+export declare class Area {
+    ids: string[];
+    entity: CanvasEntityState | ProjectState;
+    entityCardHeight: number;
+    entityCardWidth: number;
+    index: number;
+    childEntities: CanvasEntityState[];
+    children: Area[];
+    parents: Area[];
+    calculationEntryPoint: Area;
+    _onlyEntities: CanvasEntityState[] | null;
+    private _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[];
+    get changeSet(): ChangeSet;
+    set changeSet(changeSet: ChangeSet | null);
+    findAreaInChildrenFromEntity(entity: CanvasEntityState): Area | null;
+    findAreaFromEntity(entity: CanvasEntityState): Area | null;
+    addParent(parent: Area): void;
+    static resolveIds(parent: Area, index: number): string[];
+    getSortedChildren(): void;
+    calculateCardSize(): void;
+    static getBoundriesOfTwoAreas(area1: ICoordinates, area2: ICoordinates): ICoordinates;
+    static getBoundriedOfCombinedAreas(areas: Area[], until: Area[]): ICoordinates;
+    getFullAreaUntilAny(areas: Area[]): ICoordinates;
+    getFullAreaUntilAreaOrAnyChildren(childArea: Area): ICoordinates;
+    getFullAreaUntil(childArea: Area): ICoordinates;
+    get fullBranchArea(): ICoordinates;
+    get ownEntityArea(): ICoordinates;
+    get ownEntityPlusBufferArea(): ICoordinates;
+    static filterOutRepeatedAreas(areas: Area[]): Area[];
+    getEarliestId(idA: string, idB: string): string;
+    getEarliestLevel(): number;
+    countColumns(): number;
+    getLatestId(idA: string, idB: string): string;
+    getLatestLevel(): number;
+    smoothPosition(): void;
+    shiftDownUntilAny(areas: Area[], amount: number): Area[];
+    shiftRightUntilAny(areas: Area[], amount: number): void;
+    shiftRight(amount: number): void;
+    shiftDownAlone(amount: number): void;
+    centerHeaderVerticallyOverCombinedAllParentsHeaderHeight(): void;
+    centerHeaderVerticallyOverCombinedAllChildrenHeaderHeight(): number;
+    resolveChildrenOverlaps(): void;
+    static getEarliestParentInChain(area: Area): Area;
+    flattenEarlierSiblings(seenSiblings?: Set<string>): Area[];
+    flattenSiblings(seenSiblings?: Set<string>): Area[];
+    flattenChildren(seenChildren?: Set<string>): Area[];
+    flattenParents(seenParents?: Set<string>): Area[];
+    getAreaIfRendered(entity: CanvasEntityState): Area | null;
+    getLowerSiblings(): Area[];
+    getLowerAreas(): Area[];
+    adjustVerticallyToAvoidOverlaps(alreadyShiftedAreas?: Area[]): Area[];
+    move(entity: CanvasEntityState, coordinates: {
+        x: number;
+        y: number;
+    } | {
+        y: number;
+    } | {
+        x: number;
+    }): void;
+    addChild(index: number): Area | null;
+    flattenChildEntities(seenEntities?: Set<string>): CanvasEntityState[];
+    next(onLevelComplete: (renderedLevel: Area[]) => void): void;
+}

package/dist/editor/base-editor-class.d.ts

@@ -0,0 +1,220 @@
+import { EntityId, UserManagedElementShallowTransfer, EntityVersion } from '../definitions';
+import { ProjectState, UserManagedEntityState, EntityWithValueState, PersistChangeSetEntityActionRequestPayload, ChangeSet, CanvasEntityState, ChangeSetEvent, EntityError } from '../tree';
+import { IActiveBranchHeadResult, IEditor, IChannelConnections, EfimeralValueStore, ITest, Execution, IDynamicValue, DynamicValueTypes, PublicationRun, ExtensionsRegistry, TestableEntityState, ExtensionContextType, IEnvConfig, IBranch, ICanvasCopyPayload } from '.';
+import { Events, IWebsocketsClient, YieldOptions } from '@elyx-code/common-ts-utils';
+import { ILiveMessageDTO, IPublication, InfrastructureResource, IWorkspace, IRichProjectRoleDTO } from '@elyx-code/definitions';
+import { Test } from './test-instance';
+import { IEditorContext } from './extensions/contexts/editor-context';
+
+export declare class ProjectFetch {
+    projectId: string;
+    websocketConnection: IWebsocketsClient;
+    accessToken: string;
+    refreshToken: string;
+    editor: IEditor;
+    branchId: string | null;
+    projectVersion: string | null;
+    projectState: ProjectState | null;
+    branchHead: IActiveBranchHeadResult | null;
+    fetchActionId: string;
+    sessionId: string | null;
+    lastChunkIndex: number | null;
+    lastProcessedChunkIndex: number;
+    chunkCache: {
+        [key: number]: {
+            order: EntityId[];
+            size: number;
+            index: number;
+            record: Record<EntityId, UserManagedElementShallowTransfer>;
+        };
+    };
+    hasReceivedComplete: boolean;
+    allChunks: {
+        [key: number]: {
+            order: EntityId[];
+            size: number;
+            index: number;
+            record: Record<EntityId, UserManagedElementShallowTransfer>;
+        };
+    };
+    allSeenEntities: Map<EntityId, UserManagedElementShallowTransfer>;
+    seenIndexes: Set<number>;
+    resolve: ((projectState: ProjectState | null) => void) | null;
+    onProjectHeadLoadedCallback: null | ((projectState: ProjectState, branch: IActiveBranchHeadResult) => void | Promise<void>);
+    onChunkAddedCallback: null | ((chunk: {
+        order: EntityId[];
+        size: number;
+        index: number;
+        record: Record<EntityId, UserManagedEntityState>;
+    }) => void | Promise<void>);
+    onErrorCallback: null | ((error: any) => void);
+    constructor(projectId: string, websocketConnection: IWebsocketsClient, accessToken: string, refreshToken: string, editor: IEditor, // As parent context for the project
+    branchId?: string | null, projectVersion?: string | null);
+    get pageSize(): number;
+    onProjectHeadLoaded(callback: (projectState: ProjectState, branch: IActiveBranchHeadResult) => void | Promise<void>): void;
+    onChunkAdded(callback: (chunk: {
+        order: EntityId[];
+        size: number;
+        index: number;
+        record: Record<EntityId, UserManagedEntityState>;
+    }) => void | Promise<void>): void;
+    onError(callback: (error: any) => void): void;
+    processChunk(chunk: {
+        order: EntityId[];
+        size: number;
+        index: number;
+        record: Record<EntityId, UserManagedElementShallowTransfer>;
+    }): void;
+    completeInitialization(): void;
+    fetch(): Promise<ProjectState | null>;
+}
+export declare class Editor implements IEditor, IEditorContext {
+    ready: boolean;
+    hasLoadedLogic: boolean;
+    destroyed: boolean;
+    logicLoadingPromise: Promise<void> | null;
+    env: IEnvConfig;
+    logic: ProjectState | null;
+    lastPublishedProjectState: ProjectState | null;
+    branchHead: IActiveBranchHeadResult | null;
+    branchHeadPromise: Promise<IActiveBranchHeadResult | null> | null;
+    projectId: EntityId;
+    initiallyRequestedBranchId: string | null;
+    initiallyRequestedVersion: string | null;
+    id: string;
+    sessionId: string | null;
+    accessToken: string;
+    refreshToken: string;
+    userAuthorId: string;
+    peerConnections: Record<string, IChannelConnections>;
+    private _peerPendingByPrev;
+    private _peerSeenVersions;
+    private _externalChangeSetsQueue;
+    private _cachedChangeSetChunks;
+    test: Test | null;
+    localTestValues: EfimeralValueStore;
+    resolvedValues: EfimeralValueStore;
+    persistedExecutionResults: EfimeralValueStore;
+    socket: IWebsocketsClient;
+    events: Events;
+    publication: PublicationRun | null;
+    livePublishedVersions: IPublication[];
+    publications: PublicationRun[];
+    liveResources: InfrastructureResource[] | null;
+    extensionsRegistry: ExtensionsRegistry<Editor>;
+    contextType: ExtensionContextType.Editor;
+    onProjectHeadLoadedCallback: null | ((projectState: ProjectState) => void);
+    onLogicLoadingCompleteCallback: null | ((chunk: any) => void);
+    onProjectSetupErrorCallback: null | ((error: any) => void);
+    pastSessionIds: Set<string>;
+    activeWorkspace: IWorkspace;
+    tmpInitialWorkspaceString: string | null;
+    branches: IBranch[];
+    roles: IRichProjectRoleDTO[];
+    READ_ONLY: boolean;
+    constructor(projectId: EntityId, socket: IWebsocketsClient, events: Events | null, activeWorkspace: IWorkspace | string | null, options?: {
+        accessToken?: string;
+        refreshToken?: string;
+        userAuthorId?: string;
+        version?: string;
+        branchId?: string;
+    });
+    static SAVING_ENABLED: boolean;
+    static SAFE_CHUNK_WS_CONTENT_SIZE: number;
+    get execution(): Execution | null;
+    get project(): ProjectState;
+    get lastExecutionResults(): EfimeralValueStore;
+    get isViewingNonHead(): boolean;
+    get undoableStackValueIndex(): number;
+    set undoableStackValueIndex(value: number);
+    get PROJECT_NOTIFICATIONS_CHANNEL(): string;
+    get livePublication(): PublicationRun | null;
+    get canEdit(): boolean;
+    getAccessToken(): Promise<string>;
+    getRefreshToken(): Promise<string>;
+    onProjectHeadLoaded(callback: (projectState: ProjectState) => void): void;
+    onLogicLoadingComplete(callback: (chunk: any) => void): void;
+    onProjectSetupError(callback: (error: any) => void): void;
+    removeValueByOwnerId(entityId: EntityId): void;
+    removeValue(dynamicValue: IDynamicValue): void;
+    handleNotificationChannelsMessage(message: ILiveMessageDTO): void;
+    handleChunkedChangeSetMessage(message: PersistChangeSetEntityActionRequestPayload): PersistChangeSetEntityActionRequestPayload | null;
+    handlePersistChangeSetMessage(_message: PersistChangeSetEntityActionRequestPayload): Promise<void>;
+    private _cachePeerChangeSet;
+    private _tryApplyPeerQueues;
+    handleReconnectingWebsocket(): Promise<void>;
+    handleClosedWebsocket(): Promise<void>;
+    handleIncommingWebsocketMessage(message: ILiveMessageDTO): Promise<void>;
+    getLastPublishedVersionLogic(options: {
+        version: EntityVersion;
+        branchId: string;
+    }): Promise<ProjectState | null>;
+    getLogic(options?: {
+        mockLogic?: ProjectState;
+    }): Promise<ProjectState | null>;
+    getLogicThenProcessExternalChangeSetsQueue(options?: {
+        mockLogic?: ProjectState;
+    }): Promise<void>;
+    undo(): Promise<void>;
+    redo(): Promise<void>;
+    moveBranchHeadToVersion(versionId: EntityVersion, actionName: string, overrideReadOnly?: boolean): Promise<IActiveBranchHeadResult | null>;
+    get off(): Events['off'];
+    get on(): Events['on'];
+    get emit(): Events['emit'];
+    get emitAsync(): Events['emitAsync'];
+    get emitAsyncAll(): Events['emitAsyncAll'];
+    get emitAsyncAllSettled(): Events['emitAsyncAllSettled'];
+    get emitAsyncSequentially(): Events['emitAsyncSequentially'];
+    get emitAsyncSequentiallyAll(): Events['emitAsyncSequentiallyAll'];
+    get emitAsyncSequentiallyAllSettled(): Events['emitAsyncSequentiallyAllSettled'];
+    registerNonDefaultLocalImplementationsOfModules(): Promise<void>;
+    checkIsOwnSession(sessionId: string | null): boolean;
+    validateProjectState(options?: YieldOptions): Promise<void>;
+    onOfflineWindowEventHandler(): void;
+    onOnlineWindowEventHandler(): void;
+    onChangeSetEventHandler(event: ChangeSetEvent): void;
+    setupHandleConnectionStatus(): void;
+    teardownHandleConnectionStatus(): void;
+    loadPublicationsThenLastPublishedProjectState(): Promise<void>;
+    initialLoads(options?: {
+        mockLogic?: ProjectState;
+    }): Promise<void>;
+    splitCSInChunksAndSend(fullMessage: PersistChangeSetEntityActionRequestPayload): Promise<void>;
+    setup(options?: {
+        mockLogic?: ProjectState;
+    }): Promise<void>;
+    destroy(): Promise<void>;
+    getAllProjectLogicErrors(options?: YieldOptions): Promise<EntityError[]>;
+    recalculateValidate(options?: YieldOptions): Promise<void>;
+    initTest(entryPoint: TestableEntityState, options?: YieldOptions & {
+        autoExecute?: boolean;
+    }): Promise<ITest>;
+    removeTest(options?: YieldOptions & {
+        skipValidate?: boolean;
+    }): Promise<ITest>;
+    copyEntities(payload: ICanvasCopyPayload, options?: YieldOptions): Promise<ChangeSet>;
+    resolveInitialChildrenPositions(parent: CanvasEntityState | null, children: CanvasEntityState[], changeSet: ChangeSet | null): CanvasEntityState[];
+    publish(): Promise<void>;
+    loadLivePublications(): Promise<void>;
+    enrichPublication(publication: IPublication): PublicationRun;
+    enrichPublications(publications: IPublication[]): PublicationRun[];
+    loadGivenPublication(publicationId: string): Promise<IPublication>;
+    requestExtension<T = any>(moduleId: string): T;
+    requestActiveDynamicValue(valueOwner: EntityWithValueState, onlyDefault?: boolean): IDynamicValue | null;
+    initRegistry(): Promise<ExtensionsRegistry<Editor>>;
+    loadPublications(): Promise<void>;
+    getValueTypePreference(valueOwnerId: EntityId): DynamicValueTypes.DefaultValue | DynamicValueTypes.Testing | null;
+    setValueTypePreference(valueOwnerId: EntityId, valueTypePreference: DynamicValueTypes.DefaultValue | DynamicValueTypes.Testing | null): void;
+    /**
+     * A websocket action, which implements a given feature (group of logic) into the current project
+     * It will initialize a backend process which will communicate back to this client through change-sets
+     * So the processing of the response is automatic, no custom logic needed.
+     *
+     * @param featureId
+     */
+    implementFeature(featureId: string): Promise<PersistChangeSetEntityActionRequestPayload>;
+    loadInitialBranchHead(): Promise<IActiveBranchHeadResult | null>;
+    getProjectRoles({ accessToken }?: {
+        accessToken?: string;
+    }): Promise<IRichProjectRoleDTO[]>;
+}