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

package/dist/editor/extensions/module/extensions.d.ts

@@ -0,0 +1,97 @@
+import { IExecutionClient } from '../../execution';
+import { IExtensionContext } from '../contexts';
+import { ExtensionsRegistry } from '../registry';
+
+export declare enum ExtentionPriority {
+    High = 1,
+    Normal = 5,
+    Low = 10
+}
+export declare enum ExtensionContextType {
+    Logic = "logic",
+    EditorGUI = "editor-gui",
+    GUI = "gui",
+    Editor = "editor",
+    Compile = "compile",
+    PublicationRun = "publication-run"
+}
+export declare enum ExtensionPermissions {
+    All = "*",// Allow all permissions, not recommended for security reasons
+    OnAll = "on:*",// Allow listening to any event
+    EmitAll = "emit:*",// Allow emitting any event
+    ReadAll = "read:*",// Allow reading any state
+    WriteAll = "write:*",// Allow writing any state
+    UpdateAll = "update:*",// Allow updating any state
+    DoAll = "do:*",// Allow performing any action
+    OnLogicAll = "on:logic:*",// Allow listening to any event in the logic context
+    EmitLogicAll = "emit:logic:*",// Allow emitting any event in the logic context
+    ReadLogicAll = "read:logic:*",// Allow reading any state in the logic context
+    WriteLogicAll = "write:logic:*",// Allow writing any state in the logic context
+    UpdateLogicAll = "update:logic:*",// Allow updating any state in the logic context
+    DoLogicAll = "do:logic:*",// Allow performing any action in the logic context
+    OnGUIAll = "on:gui:*",// Allow listening to any event in the GUI context
+    EmitGUIAll = "emit:gui:*",// Allow emitting any event in the GUI context
+    ReadGUIAll = "read:gui:*",// Allow reading any state in the GUI context
+    WriteGUIAll = "write:gui:*",// Allow writing any state in the GUI context
+    UpdateGUIAll = "update:gui:*",// Allow updating any state in the GUI context
+    DoGUIAll = "do:gui:*",// Allow performing any action in the GUI context
+    OnEditorAll = "on:editor:*",// Allow listening to any event in the editor context
+    EmitEditorAll = "emit:editor:*",// Allow emitting any event in the editor context
+    ReadEditorAll = "read:editor:*",// Allow reading any state in the editor context
+    WriteEditorAll = "write:editor:*",// Allow writing any state in the editor context
+    UpdateEditorAll = "update:editor:*",// Allow updating any state in the editor context
+    DoEditorAll = "do:editor:*",// Allow performing any action in the editor context
+    OnCompileBefore = "on:compile:before:DefinitionEntity",
+    OnCompileDefault = "on:compile:default:DefinitionEntity",
+    OnCompileAfter = "on:compile:after:DefinitionEntity",
+    EmitCompile = "emit:compile:DefinitionEntity",
+    DoEditorPublish = "do:editor:publish",
+    PostGUICanvasSlotNewToolbarButton = "write:gui:canvas:slot:toolbar-button",
+    ReadGUICanvasSlotToolbarButtons = "read:gui:canvas:slot:toolbar-buttons",
+    UpdateGUIGlobalTheme = "update:gui:global:theme"
+}
+export interface ExtensionManifest {
+    id: string;
+    version: string;
+    description?: string;
+    initPriority?: ExtentionPriority;
+    permissions: ExtensionPermissions[];
+    contexts: ExtensionContextType[];
+    dependencies?: string[];
+}
+export interface IExtensionModuleCore {
+    /** Called once on editor startup */
+    init?(contexts: IExtensionContext[]): Promise<void> | void;
+    /** Cleanup hook */
+    destroy?(): Promise<void> | void;
+}
+export type ExtensionModule<T = any> = T & IExtensionModuleCore;
+export interface IExtensionState {
+    set(key: string, value: any): void;
+    get(key: string): any | undefined;
+    delete(key: string): void;
+}
+export declare class BaseExtensionState implements IExtensionState {
+    private state;
+    constructor(initialState?: Record<string, any>);
+    get(key: string): any | undefined;
+    set(key: string, value: any): void;
+    delete(key: string): void;
+}
+export declare class ExtensionState extends BaseExtensionState implements IExtensionState {
+    parentExtension: IRegisteredExtension;
+    constructor(parentExtension: IRegisteredExtension, initialState?: Record<string, any>);
+}
+export interface IRegisteredExtension<T = any> extends IExecutionClient {
+    extensionsRegistry: ExtensionsRegistry;
+    manifest: ExtensionManifest;
+    module: ExtensionModule<T>;
+    state: IExtensionState;
+}
+export declare class BaseRegisteredExtension<T = any> implements IRegisteredExtension<T> {
+    readonly extensionsRegistry: ExtensionsRegistry;
+    manifest: ExtensionManifest;
+    module: ExtensionModule<T>;
+    state: ExtensionState;
+    constructor(extensionsRegistry: ExtensionsRegistry, initialState?: Record<string, any>);
+}

package/dist/editor/extensions/module/index.d.ts

@@ -0,0 +1,2 @@
+export * from './extensions';
+export * from './defaults';

package/dist/editor/extensions/registry/index.d.ts

@@ -0,0 +1,52 @@
+import { EventCallback, EventCallbackArguments, Events, IEventsBus } from '@elyx-code/common-ts-utils';
+import { ExtensionContextType, IRegisteredExtension } from '../module/extensions';
+import { DefaultProjectLogicContext, ExtensionContextBase, ICompilerContext } from '../contexts';
+import { IEditorContext } from '../contexts/editor-context';
+import { DefaultPublicationRunContext, IPublicationRunContext } from '../contexts/publication-context';
+import { EntityId } from '../../../definitions';
+import { DynamicValueTypes } from '../../value-store';
+
+export interface IBaseExtensionsContext {
+    requestExtension: <T = any>(moduleId: string) => IRegisteredExtension<T>;
+}
+export declare class ExtensionsRegistry<TEditorContext extends Omit<IEditorContext, '_editor'> = IEditorContext, TProjectLogicContext extends DefaultProjectLogicContext = DefaultProjectLogicContext, TCompilerContext extends ICompilerContext = ICompilerContext, TPublicationRunContext extends Omit<IPublicationRunContext, '_publicationRun'> = Omit<DefaultPublicationRunContext, '_publicationRun'>, TEditorGUIContext extends ExtensionContextBase<ExtensionContextType.EditorGUI> = any, TGUIContext extends ExtensionContextBase<ExtensionContextType.GUI> = any> implements Omit<IEventsBus, 'destroy'> {
+    private events;
+    private extensionsRegistry;
+    private initialized;
+    private initializedContexts;
+    onResolveEditorContextCallback: () => TEditorContext | null;
+    onResolveProjectLogicContextCallback: () => TProjectLogicContext | null;
+    onResolveEditorGUIContextCallback: () => TEditorGUIContext | null;
+    onResolveGUIContextCallback: () => TGUIContext | null;
+    onResolveCompileContextCallback: () => TCompilerContext | null;
+    onResolvePublicationRunContextCallback: () => TPublicationRunContext | null;
+    constructor(events?: Events);
+    onResolveEditorContext(callback: () => TEditorContext | null): void;
+    onResolveProjectLogicContext(callback: () => TProjectLogicContext | null): void;
+    onResolveGUIContext(callback: () => TGUIContext | null): void;
+    onResolveEditorGUIContext(callback: () => TEditorGUIContext | null): void;
+    onResolveCompileContext(callback: () => TCompilerContext | null): void;
+    onResolvePublicationRunContext(callback: () => TPublicationRunContext | null): void;
+    get extensionInOrder(): IRegisteredExtension[];
+    setup(): Promise<void>;
+    private requestContext;
+    requestContexts(_module: IRegisteredExtension<any>, _contextTypes?: ExtensionContextType[]): (TEditorContext | TProjectLogicContext | TCompilerContext | TPublicationRunContext | TEditorGUIContext | TGUIContext)[];
+    requestExtension<T = any>(moduleId: string): IRegisteredExtension<T>;
+    register(extension: IRegisteredExtension<any>): void;
+    initAll(): Promise<void>;
+    initForReady(): Promise<void>;
+    destroyAll(): Promise<void>;
+    on<Arguments extends any[]>(eventName: string, callback: EventCallback<Arguments>): void;
+    emit<Arguments extends any[]>(eventName: string, ...args: Arguments): void;
+    off<Arguments extends any[]>(eventName: string, callback?: EventCallback<Arguments>): void;
+    emitAsync<Arguments extends any[]>(eventName: string, ...args: EventCallbackArguments<Arguments>): Promise<void>;
+    emitAsyncAll<Arguments extends any[]>(eventName: string, ...args: EventCallbackArguments<Arguments>): Promise<void>;
+    emitAsyncAllSettled<Arguments extends any[]>(eventName: string, ...args: EventCallbackArguments<Arguments>): Promise<PromiseSettledResult<any>[]>;
+    emitAsyncSequentially<Arguments extends any[]>(eventName: string, ...args: EventCallbackArguments<Arguments>): Promise<void>;
+    emitAsyncSequentiallyAll<Arguments extends any[]>(eventName: string, ...args: EventCallbackArguments<Arguments>): Promise<void>;
+    emitAsyncSequentiallyAllSettled<Arguments extends any[]>(eventName: string, ...args: EventCallbackArguments<Arguments>): Promise<PromiseSettledResult<any>[]>;
+    contextAvailable(contextType: ExtensionContextType): Promise<void>;
+    getValueTypePreference(valueOwnerId: EntityId): DynamicValueTypes.DefaultValue | DynamicValueTypes.Testing | null;
+    setValueTypePreference(valueOwnerId: EntityId, valueTypePreference: DynamicValueTypes.DefaultValue | DynamicValueTypes.Testing | null): void;
+}
+export declare const DEFAULT_BASE_EXTENSIONS_CONTEXT: IBaseExtensionsContext;

package/dist/editor/extensions/registry/register-defaults.d.ts

@@ -0,0 +1,3 @@
+import { ExtensionsRegistry } from '.';
+
+export declare function registerDefaultExtensions(extensionsRegistry: ExtensionsRegistry<any, any>): void;

package/dist/editor/index.d.ts

@@ -0,0 +1,11 @@
+export * from './editor';
+export * from './execution';
+export * from './value-store';
+export * from './test';
+export * from './value-resolution';
+export * from './area';
+export * from './layout';
+export * from './ui-utils';
+export * from './publication';
+export * from './extensions';
+export * from './utils';

package/dist/editor/layout.d.ts

@@ -0,0 +1,6 @@
+import { CallerEntityState, ChangeSet, ProjectState } from '../tree';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare function layoutFullProjectCanvas(project: ProjectState, changeSet: ChangeSet, options?: YieldOptions): Promise<void>;
+export declare function layoutFromCallsFromGivenCaller(caller: CallerEntityState, changeSet: ChangeSet, options?: YieldOptions): Promise<void>;
+export declare function layoutOnlyModifiedEntryPointCanvas(project: ProjectState, changeSet: ChangeSet, options?: YieldOptions): Promise<void>;

package/dist/editor/publication/index.d.ts

@@ -0,0 +1,2 @@
+export * from './publication';
+export * from './utils';

package/dist/editor/publication/publication.d.ts

@@ -0,0 +1,153 @@
+import { CloudProviders, IDeploymentStepDefinition, IInfrastructureResource, InfrastructureResourceDetails, InfrastructureResourceType, ProjectPublicationEventName, PublicationStatus, PublishingSequenceStep, ILiveMessageDTO, IPublication, PublicationStepStatus, IRelationalDatabaseInfrastructureResource, IRelationalDatabaseDetails, IHttpApiInfrastructureResource, IHttpApiDetails, IServerlessFunctionDetails, IServerlessFunctionInfrastructureResource, IHttpEndpointInfrastructureResource, IHTTPRouteDetails, ICloudHostedCodebaseInfrastructureResource, ICloudHostedCodebaseDetails, ICompiledLocalCodebaseDetails, ICompiledLocalCodebaseInfrastructureResource, IAWSTenantAccountInfrastructureResource, IAWSTenantAccountDetails } from '@elyx-code/definitions';
+import { IEditor } from '../editor';
+import { DefinitionEntityState, ProjectState } from '../../tree';
+import { EntityId } from '../../definitions';
+import { IPublicationRun, IPublicationRunContext } from '../extensions/contexts/publication-context';
+import { ExtensionContextType, ExtensionsRegistry } from '../extensions';
+import { Events } from '@elyx-code/common-ts-utils';
+
+export declare function getHTTPAPINameFromProjectId(projectId: string): string;
+export declare function getRelationalDBInstanceNameFromEntityId(entityId: string): string;
+export declare class PublicationStep implements IDeploymentStepDefinition<ExplicitInfrastructureResource | ImplicitGlobalInfrastructureResource> {
+    stepType: PublishingSequenceStep;
+    id: string;
+    resourceType: InfrastructureResourceType | null;
+    index: number;
+    dependency: string[];
+    lastEvent?: ProjectPublicationEventName | null;
+    lastEventTimestamp: string | null;
+    status: PublicationStepStatus;
+    publicationRun: PublicationRun;
+    resource: ExplicitInfrastructureResource | ImplicitGlobalInfrastructureResource;
+    constructor(stepType: PublishingSequenceStep, id: string, resourceType: InfrastructureResourceType, initialStatus: PublicationStepStatus, dependency: string[], index: number, lastEventTimestamp: string, publicationRun: PublicationRun, resource: ExplicitInfrastructureResource | ImplicitGlobalInfrastructureResource);
+    toJSON(): IDeploymentStepDefinition;
+    update(step: IDeploymentStepDefinition): Promise<void>;
+}
+export declare enum InfrastructureResourceStatus {
+    Ready = "ready",
+    Provisioning = "provisioning",
+    Queued = "queued",
+    ProvisioningFailed = "provisioning-failed",
+    Deleting = "deleting",
+    DeletingFailed = "deleting-failed",
+    Deleted = "deleted"
+}
+export declare class InfrastructureResource implements IInfrastructureResource {
+    provisionedBy: PublicationStep;
+    publicationRun: PublicationRun;
+    resourceType: InfrastructureResourceType;
+    provider: CloudProviders;
+    resourceId: string;
+    details: InfrastructureResourceDetails | null;
+    name: string | null;
+    status: InfrastructureResourceStatus;
+    constructor(publicationRun: PublicationRun, resourceType: InfrastructureResourceType, provider: CloudProviders);
+    setDetails(details: InfrastructureResourceDetails): void;
+    setStatus(status: InfrastructureResourceStatus): void;
+    setProvisionedBy(step: PublicationStep): void;
+}
+export declare class HttpEndpointInfrastructureResource extends InfrastructureResource implements IHttpEndpointInfrastructureResource {
+    resourceType: InfrastructureResourceType.HttpEndpoint;
+    owners: Map<EntityId, DefinitionEntityState>;
+    details: IHTTPRouteDetails | null;
+    name: null;
+    status: InfrastructureResourceStatus;
+    constructor(publicationRun: PublicationRun, owners: DefinitionEntityState[], provider: CloudProviders);
+    resolveDeterministicResourceId(): string;
+}
+export declare class ServerlessFunctionInfrastructureResource extends InfrastructureResource implements IServerlessFunctionInfrastructureResource {
+    resourceType: InfrastructureResourceType.ServerlessFunction;
+    owners: Map<EntityId, DefinitionEntityState>;
+    details: IServerlessFunctionDetails | null;
+    name: null;
+    status: InfrastructureResourceStatus;
+    constructor(publicationRun: PublicationRun, owners: DefinitionEntityState[], provider: CloudProviders);
+    resolveDeterministicResourceId(): string;
+}
+export declare class HttpApiInfrastructureResource extends InfrastructureResource implements IHttpApiInfrastructureResource {
+    resourceType: InfrastructureResourceType.HttpApi;
+    owners: Map<EntityId, DefinitionEntityState>;
+    details: IHttpApiDetails | null;
+    name: null;
+    status: InfrastructureResourceStatus;
+    constructor(publicationRun: PublicationRun, owners: DefinitionEntityState[], provider: CloudProviders);
+    resolveDeterministicResourceId(): string;
+}
+export declare class RelationalDatabaseInfrastructureResource extends InfrastructureResource implements IRelationalDatabaseInfrastructureResource {
+    resourceType: InfrastructureResourceType.RelationalDatabase;
+    owners: Map<EntityId, DefinitionEntityState>;
+    details: IRelationalDatabaseDetails | null;
+    name: string;
+    status: InfrastructureResourceStatus;
+    constructor(publicationRun: PublicationRun, owners: DefinitionEntityState[], provider: CloudProviders);
+    resolveDeterministicResourceId(): string;
+}
+export declare class CloudHostedCodebaseInfrastructureResource extends InfrastructureResource implements ICloudHostedCodebaseInfrastructureResource {
+    resourceType: InfrastructureResourceType.CloudHostedCodebase;
+    details: ICloudHostedCodebaseDetails | null;
+    name: null;
+    status: InfrastructureResourceStatus;
+    constructor(publicationRun: PublicationRun, provider: CloudProviders);
+    resolveDeterministicResourceId(): string;
+}
+export declare class CompiledLocalCodebaseInfrastructureResource extends InfrastructureResource implements ICompiledLocalCodebaseInfrastructureResource {
+    resourceType: InfrastructureResourceType.CompiledLocalCodebase;
+    details: ICompiledLocalCodebaseDetails | null;
+    name: null;
+    status: InfrastructureResourceStatus;
+    constructor(publicationRun: PublicationRun, provider: CloudProviders);
+    resolveDeterministicResourceId(): string;
+}
+export declare class AWSTenantAccountInfrastructureResource extends InfrastructureResource implements IAWSTenantAccountInfrastructureResource {
+    resourceType: InfrastructureResourceType.AWSTenantAccount;
+    details: IAWSTenantAccountDetails;
+    name: null;
+    status: InfrastructureResourceStatus;
+    constructor(publicationRun: PublicationRun, provider: CloudProviders);
+    resolveDeterministicResourceId(): string;
+}
+export type ExplicitInfrastructureResource = RelationalDatabaseInfrastructureResource | HttpApiInfrastructureResource | ServerlessFunctionInfrastructureResource | HttpEndpointInfrastructureResource;
+export type ImplicitGlobalInfrastructureResource = CloudHostedCodebaseInfrastructureResource | CompiledLocalCodebaseInfrastructureResource | AWSTenantAccountInfrastructureResource;
+export declare class PublicationRun implements IPublicationRun, IPublicationRunContext {
+    id: string;
+    projectAutoIncrementPublicationCount: number;
+    projectPublishedSemanticVersion: string;
+    envIdentifier: string;
+    projectVersion: string;
+    projectBranchId: string;
+    projectId: string;
+    triggeredBy: string;
+    createdAt: string;
+    updatedAt: string;
+    status: PublicationStatus;
+    steps: PublicationStep[];
+    editor: IEditor;
+    explicitResources: Map<string, ExplicitInfrastructureResource>;
+    implicitGlobalResources: Map<InfrastructureResourceType.CompiledLocalCodebase | InfrastructureResourceType.CloudHostedCodebase | InfrastructureResourceType.AWSTenantAccount, ImplicitGlobalInfrastructureResource | null>;
+    finalGlobalEvent: ProjectPublicationEventName | null;
+    finalStatus: PublicationStatus.Success | PublicationStatus.Failed | null;
+    contextType: ExtensionContextType.PublicationRun;
+    extensionsRegistry: ExtensionsRegistry<any, any, any, PublicationRun>;
+    constructor(data: IPublication, editor: IEditor);
+    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'];
+    get project(): ProjectState;
+    getInfraTypes(resourceTypes: InfrastructureResourceType[]): PublicationStep[];
+    getStepsTypes(stepTypes: PublishingSequenceStep[]): PublicationStep[];
+    toIds(steps: PublicationStep[]): string[];
+    getResourceForEntity(entity: DefinitionEntityState): InfrastructureResource | null;
+    init(): Promise<void>;
+    initResources(): Promise<void>;
+    setSteps(steps: IDeploymentStepDefinition[], emittedAt: string): void;
+    addStep(step: IDeploymentStepDefinition, emittedAt: string): void;
+    onUpdate(message: ILiveMessageDTO): void;
+    requestExtension<T = any>(moduleId: string): T;
+    initRegistry(): Promise<ExtensionsRegistry<any, any, any, PublicationRun>>;
+}

package/dist/editor/publication/utils.d.ts

@@ -0,0 +1,13 @@
+import { ProjectPublicationEventName, PublishingSequenceStep, InfrastructureResourceType, PublicationStepStatus } from '@elyx-code/definitions';
+
+export declare function getStepNameFromDefinition(stepType: PublishingSequenceStep): string;
+export declare function getEventNameFromDefinition(event: ProjectPublicationEventName): string;
+export declare enum PUBLISHING_DISABLED_REASONS {
+    NO_LOGIC = "NO_LOGIC",
+    NO_NAME = "NO_NAME",
+    NO_CHANGES = "NO_CHANGES",
+    PROJECT_PUBLICATION_ALREADY_ONGOING = "PROJECT_PUBLICATION_ALREADY_ONGOING"
+}
+export declare function fromPublishingDisabledCodeToReadable(code: PUBLISHING_DISABLED_REASONS): string;
+export declare function resolveResourceNameFromType(resourceType: InfrastructureResourceType): string;
+export declare function resolvePublicationStepStatusFromType(eventType: PublicationStepStatus): string;

package/dist/editor/test-instance.d.ts

@@ -0,0 +1,52 @@
+import { ReturnStatementState, ContinueStatementState, BreakStatementState, EntityWithValueState, DraggablePlayableEntityState, EntityError } from '../tree';
+import { TestableEntityState, IEditor, IDynamicValue, ITest, Execution, IExecutionCallbackContext, IExecutionResult } from '.';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare function validateLogic(entities: TestableEntityState[], project: IEditor): EntityError[];
+export declare function validateLogicAsync(entities: TestableEntityState[], project: IEditor, options?: YieldOptions): Promise<EntityError[]>;
+export interface IEntityComponentProps {
+    entity: DraggablePlayableEntityState | ReturnStatementState | ContinueStatementState | BreakStatementState;
+    project: IEditor;
+    disabled?: boolean;
+}
+export declare class Test extends Execution implements ITest {
+    editor: IEditor;
+    entitiesRelatedToExecution: TestableEntityState[];
+    validation: EntityError[];
+    persistExecutionValues: boolean;
+    constructor(project: IEditor, entryPoint: TestableEntityState);
+    initExecutionValueStores(): void;
+    pause(): Promise<void>;
+    stop(options?: YieldOptions): Promise<void>;
+    resume(): Promise<void>;
+    close(options?: YieldOptions): Promise<void>;
+    restart(options?: YieldOptions): Promise<void>;
+    onValueWritten(_owner: EntityWithValueState, _value: IDynamicValue): void;
+    onValueRemoved(_owner: EntityWithValueState): void;
+    init(options?: YieldOptions & {
+        autoExecute?: boolean;
+    }): Promise<void>;
+    clear(): Promise<void>;
+    resolveIsContinuationOfSelectedLogic(entity: TestableEntityState): boolean;
+    recalculateEntitiesRelatedToTest(): void;
+    recalculateEntitiesRelatedToTestAsync(options?: YieldOptions): Promise<void>;
+    removeIfUnconnected(entity: TestableEntityState): boolean;
+    removeEntity(entity: TestableEntityState): void;
+    addEntity(entity: TestableEntityState): void;
+    getCanBeAddedToTest(entity: TestableEntityState): boolean;
+    removeFromCanBeAddedToTest(entity: TestableEntityState): void;
+    addToCanBeAddedToTest(entity: TestableEntityState): void;
+    getCanBeRemovedFromTest(entity: TestableEntityState): boolean;
+    validateLogic(): EntityError[];
+    validateLogicAsync(options?: YieldOptions): Promise<EntityError[]>;
+    validate(): void;
+    validateAsync(options?: YieldOptions): Promise<void>;
+    onBeforeEntityExecution(entity: TestableEntityState, values: IDynamicValue[], context: IExecutionCallbackContext): Promise<void>;
+    notifyEntity(entity: TestableEntityState): void;
+    notifyEntityAsync(entity: TestableEntityState): Promise<void>;
+    onEntityExecuted(entity: TestableEntityState, _result: IExecutionResult, context: IExecutionCallbackContext): Promise<void>;
+    start(_options?: YieldOptions): Promise<void>;
+    handleInvalidLogic(): Promise<void>;
+    notifyAllEntities(): void;
+    notifyAllEntitiesAsync(options?: YieldOptions): Promise<void>;
+}

package/dist/editor/test.d.ts

@@ -0,0 +1,50 @@
+import { ReturnStatementState, ContinueStatementState, BreakStatementState, EntityWithValueState, DraggablePlayableEntityState, EntityError } from '../tree';
+import { Execution, IExecutionCallbackContext, IExecutionResult, TestableEntityState } from './execution';
+import { IEditor } from './editor';
+import { IDynamicValue } from './value-store';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export interface IEntityComponentProps {
+    entity: DraggablePlayableEntityState | ReturnStatementState | ContinueStatementState | BreakStatementState;
+    project: IEditor;
+    disabled?: boolean;
+}
+export interface ITest extends Execution {
+    editor: IEditor;
+    entitiesRelatedToExecution: TestableEntityState[];
+    validation: EntityError[];
+    persistExecutionValues: boolean;
+    initExecutionValueStores(): void;
+    pause(options?: YieldOptions): Promise<void>;
+    stop(options?: YieldOptions): Promise<void>;
+    resume(options?: YieldOptions): Promise<void>;
+    restart(options?: YieldOptions): Promise<void>;
+    start(options?: YieldOptions): Promise<void>;
+    onValueWritten(owner: EntityWithValueState, value: IDynamicValue): void;
+    onValueRemoved(owner: EntityWithValueState): void;
+    init(options: YieldOptions & {
+        autoExecute?: boolean;
+    }): Promise<void>;
+    clear(): Promise<void>;
+    resolveIsContinuationOfSelectedLogic(entity: TestableEntityState): boolean;
+    recalculateEntitiesRelatedToTest(): void;
+    recalculateEntitiesRelatedToTestAsync(options?: YieldOptions): Promise<void>;
+    removeIfUnconnected(entity: TestableEntityState): boolean;
+    removeEntity(entity: TestableEntityState): void;
+    addEntity(entity: TestableEntityState): void;
+    getCanBeAddedToTest(entity: TestableEntityState): boolean;
+    removeFromCanBeAddedToTest(entity: TestableEntityState): void;
+    addToCanBeAddedToTest(entity: TestableEntityState): void;
+    getCanBeRemovedFromTest(entity: TestableEntityState): boolean;
+    validateLogic(): EntityError[];
+    validateLogicAsync(options?: YieldOptions): Promise<EntityError[]>;
+    validate(): void;
+    validateAsync(options?: YieldOptions): Promise<void>;
+    onBeforeEntityExecution(entity: TestableEntityState, values: IDynamicValue[], context: IExecutionCallbackContext): Promise<void>;
+    onEntityExecuted(entity: TestableEntityState, result: IExecutionResult, context: IExecutionCallbackContext): Promise<void>;
+    handleInvalidLogic(): Promise<void>;
+    notifyEntity(entity: TestableEntityState): void;
+    notifyEntityAsync(entity: TestableEntityState, options: YieldOptions): Promise<void>;
+    notifyAllEntities(): void;
+    notifyAllEntitiesAsync(options: YieldOptions): Promise<void>;
+}