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

package/dist/editor/editor.d.ts

@@ -0,0 +1,199 @@
+import { CanvasEntityState, ChangeSet, IProjectInstanceParentContext, PersistChangeSetEntityActionRequestPayload, ProjectState } from '../tree';
+import { Execution, TestableEntityState } from './execution';
+import { EfimeralValueStore, IDynamicValue, IValueStoreClient } from './value-store';
+import { EntityId, EntityType, EntityVersion, UserManagedElementShallowTransfer } from '../definitions';
+import { ITest } from './test';
+import { IValueResolutionContext } from './value-resolution';
+import { Events, IWebsocketsClient, YieldOptions } from '@elyx-code/common-ts-utils';
+import { DTOAction, ILiveMessageDTO, InfrastructureResource, IPublication, IRichProjectRoleDTO, IWorkspace } from '@elyx-code/definitions';
+import { PublicationRun } from './publication/publication';
+import { ExtensionContextType, ExtensionsRegistry, IRegisteredExtension } from './extensions';
+
+export interface IBranch {
+    id: string;
+    userAuthor: string;
+    project: string;
+    fromVersionId: string;
+    name: string;
+    identifier: string;
+    createdAt: string;
+    default: boolean;
+}
+export interface IBranchHead {
+    id: string;
+    branch: string;
+    userAuthor: string;
+    versionId: string;
+    timestamp: string;
+    actionName: string | null;
+    selfId: EntityId;
+    selfType: EntityType;
+    selfVersion: EntityVersion;
+}
+export interface IBranchMerge {
+    id: string;
+    branch: string;
+    userAuthor: string;
+    mergedIntoBranch: string | null;
+    mergedAsNewVersion: string | null;
+    mergedIntoVersion: string | null;
+    timestamp: string;
+}
+export interface IActiveBranchHeadResult {
+    branchId: string;
+    headVersion: string;
+    userAuthor: string;
+    timestamp: string;
+    fromVersionId: string;
+    name: string;
+    identifier: string;
+    createdAt: string;
+    project: string;
+    selfId: EntityId;
+    selfType: EntityType;
+    selfVersion: EntityVersion;
+}
+export interface IUndoableInterface {
+    undo: () => void;
+    redo: () => void;
+    undoableStackValueIndex: number;
+}
+export interface IChannelConnections {
+    channel: string;
+    connections: {
+        connectionId: string;
+        userId: string;
+    }[];
+}
+export interface IEnvConfig {
+    API_BASE_URL: string;
+    WS_URL: string;
+    amplifyConfig: {
+        aws_project_region: string;
+        aws_cognito_region: string;
+        aws_user_pools_id: string;
+        aws_user_pools_web_client_id: string;
+        aws_cognito_username_attributes: string[];
+        aws_cognito_signup_attributes: string[];
+        aws_cognito_password_protection_settings: {
+            passwordPolicyMinLength: number;
+            passwordPolicyCharacters: string[];
+        };
+        aws_cognito_verification_mechanisms: string[];
+    };
+    HELP_ARTICLES_URL: string;
+    PUBLIC_EXTERNAL_INTEGRATIONS_URL: string;
+    EXTERNAL_INTEGRATIONS_URL: string;
+    EXTERNAL_INTEGRATIONS_CONNECT_URL: string;
+    EXTERNAL_INTEGRATIONS_LOGOS_URL: string;
+    HTTP_CLIENT_URL: string;
+    EDITOR_RUNTIME_IP_ADDRESS: string;
+    GOOGLE_PICKER_APP_ID: string;
+    GOOGLE_PICKER_API_KEY: string;
+    stripe_publishable_key: string;
+    stripe_pricing_table_id: string;
+    stripe_personal_sub_mngmt_url: string;
+    stripe_org_sub_mngmt_url: string;
+}
+export interface ICanvasCopyPayload {
+    elyx_entities: UserManagedElementShallowTransfer[];
+    elyx_project_id: string;
+}
+export interface IEditor extends IUndoableInterface, IValueResolutionContext, IProjectInstanceParentContext {
+    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;
+    id: string;
+    sessionId: string | null;
+    userAuthorId: string;
+    peerConnections: Record<string, IChannelConnections>;
+    test: ITest | null;
+    localTestValues: IValueStoreClient;
+    resolvedValues: IValueStoreClient;
+    persistedExecutionResults: IValueStoreClient;
+    socket: IWebsocketsClient;
+    events: Events;
+    publication: PublicationRun | null;
+    extensionsRegistry: ExtensionsRegistry<any>;
+    contextType: ExtensionContextType.Editor;
+    livePublishedVersions: IPublication[];
+    publications: PublicationRun[];
+    liveResources: InfrastructureResource[] | null;
+    activeWorkspace: IWorkspace;
+    branches: IBranch[];
+    roles: IRichProjectRoleDTO[];
+    READ_ONLY: boolean;
+    onProjectHeadLoadedCallback: null | ((projectState: ProjectState) => void);
+    onLogicLoadingCompleteCallback: null | ((chunk: any) => void);
+    onProjectSetupErrorCallback: null | ((error: any) => void);
+    get execution(): Execution | null;
+    get project(): ProjectState;
+    get lastExecutionResults(): EfimeralValueStore;
+    get undoableStackValueIndex(): number;
+    set undoableStackValueIndex(value: number);
+    get PROJECT_NOTIFICATIONS_CHANNEL(): string;
+    get isViewingNonHead(): boolean;
+    get canEdit(): boolean;
+    getAccessToken(): Promise<string | null>;
+    getRefreshToken(): Promise<string | null>;
+    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;
+    validateProjectState(options?: YieldOptions): Promise<void>;
+    handleIncommingWebsocketMessage(message: ILiveMessageDTO): Promise<void>;
+    handleNotificationChannelsMessage(message: ILiveMessageDTO<DTOAction.SubscribeChannelsV1, string, {
+        channels: IChannelConnections[];
+        sessionId: string;
+    }>): void;
+    handleReconnectingWebsocket(): void;
+    handleChunkedChangeSetMessage(message: PersistChangeSetEntityActionRequestPayload): PersistChangeSetEntityActionRequestPayload | null;
+    handlePersistChangeSetMessage(message: PersistChangeSetEntityActionRequestPayload): void;
+    getLastPublishedVersionLogic(options: {
+        version: EntityVersion;
+        branchId: string;
+    }): Promise<ProjectState | null>;
+    getLogic(options?: {
+        mockLogic?: ProjectState;
+    }): Promise<ProjectState | null>;
+    initialLoads(options: {
+        mockLogic?: ProjectState;
+    }): Promise<void>;
+    undo(): Promise<void>;
+    redo(): Promise<void>;
+    moveBranchHeadToVersion(versionId: EntityVersion, actionName: string, overrideReadOnly?: boolean): Promise<IActiveBranchHeadResult | null>;
+    on: Events['on'];
+    emit: Events['emit'];
+    off: Events['off'];
+    emitAsync: Events['emitAsync'];
+    registerNonDefaultLocalImplementationsOfModules(): Promise<void>;
+    setup(options: {
+        mockLogic?: ProjectState;
+    }): Promise<void>;
+    destroy(): 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>;
+    loadGivenPublication(publicationId: string): Promise<IPublication>;
+    requestExtension<T = any>(moduleId: string): IRegisteredExtension<T>;
+    initRegistry(): Promise<ExtensionsRegistry<any>>;
+    implementFeature(featureId: string): Promise<PersistChangeSetEntityActionRequestPayload>;
+    loadInitialBranchHead(): Promise<IActiveBranchHeadResult | null>;
+    getProjectRoles(options?: {
+        accessToken?: string;
+    }): Promise<IRichProjectRoleDTO[]>;
+}

package/dist/editor/execution.d.ts

@@ -0,0 +1,165 @@
+import { EntityId } from '../definitions';
+import { BreakStatementState, ContinueStatementState, EntityState, ExecutionTerminationType, LoopState, ProjectState, SearchState, ConditionState, FunctionCallState, OperationState, FunctionDeclarationState, ReturnStatementState, EntryPointEntityState, VariableState, ExecutableEntityState, InternalCallState } from '../tree';
+import { IValueResolutionContext } from './value-resolution';
+import { DynamicValueTypes, EfimeralValueStore, IDynamicValue } from './value-store';
+import { Events, YieldOptions } from '@elyx-code/common-ts-utils';
+import { IBaseExtensionsContext } from './extensions';
+
+export type TestableEntityState = ExecutableEntityState;
+export interface IExecutionResult {
+    value: ExecutionTerminationType;
+    entity: TestableEntityState;
+    error: IDynamicValue | null;
+    result: IDynamicValue | null;
+}
+export interface IExecutionCallbackContext {
+    detached: boolean;
+    execution?: Execution;
+}
+export interface IExecutionClient {
+    onBeforeEntityExecution?: (entity: TestableEntityState, inputs: IDynamicValue[], context: IExecutionCallbackContext) => Promise<any>;
+    onEntityExecuted?: (entity: TestableEntityState, result: IExecutionResult, context: IExecutionCallbackContext) => Promise<any>;
+}
+export declare class ExecutionStoppedError extends Error {
+    constructor();
+}
+export declare enum ExecutionState {
+    FinishedSuccess = "finished-success",
+    FinishedError = "finished-error",
+    Running = "running",
+    Paused = "paused",
+    Stopped = "stopped",
+    NotStarted = "not-started"
+}
+export interface IExecutionInstanceParentContext extends IBaseExtensionsContext {
+    getValueTypePreference: (valueOwnerId: EntityId) => DynamicValueTypes.DefaultValue | DynamicValueTypes.Testing | null;
+    setValueTypePreference: (valueOwnerId: EntityId, valueTypePreference: DynamicValueTypes.DefaultValue | DynamicValueTypes.Testing | null) => void;
+}
+export declare const DEFAULT_EXECUTION_INSTANCE_PARENT_CONTEXT: IExecutionInstanceParentContext;
+export declare class Execution extends Events {
+    readonly parentContext: IExecutionInstanceParentContext;
+    project: ProjectState;
+    entryPoint: TestableEntityState;
+    state: ExecutionState;
+    events: Events;
+    entities: TestableEntityState[];
+    parentExecution: Execution | null;
+    executing: TestableEntityState[];
+    executed: TestableEntityState[];
+    skipped: TestableEntityState[];
+    scheduled: TestableEntityState[];
+    localTestValues: EfimeralValueStore;
+    resolvedValues: EfimeralValueStore;
+    persistedExecutionResults: EfimeralValueStore;
+    lastExecutionResults: EfimeralValueStore;
+    onAddToSkippedListCallback: null | ((entity: TestableEntityState, options?: YieldOptions & {
+        skipValidate?: boolean;
+        skipRender?: boolean;
+        skipNotify?: boolean;
+    }) => Promise<void> | void);
+    onRemoveFromSkippedListCallback: null | ((entity: TestableEntityState, options?: YieldOptions & {
+        skipValidate?: boolean;
+        skipRender?: boolean;
+        skipNotify?: boolean;
+    }) => Promise<void> | void);
+    onAddEntityCallback: null | ((entity: TestableEntityState, options?: YieldOptions & {
+        skipValidate?: boolean;
+        skipRender?: boolean;
+        skipNotify?: boolean;
+    }) => Promise<void> | void);
+    onRemoveEntityCallback: null | ((entity: TestableEntityState, options?: YieldOptions & {
+        skipValidate?: boolean;
+        skipRender?: boolean;
+        skipNotify?: boolean;
+    }) => Promise<void> | void);
+    onAbortExecutionCallback: null | ((entity: TestableEntityState, options?: YieldOptions & {
+        skipValidate?: boolean;
+        skipRender?: boolean;
+        skipNotify?: boolean;
+    }) => Promise<void> | void);
+    constructor(project: ProjectState, entities: TestableEntityState[], entryPoint: TestableEntityState, parentExecution?: Execution | null, parentContext?: IExecutionInstanceParentContext);
+    get valueResolutionContext(): IValueResolutionContext;
+    get rootExecution(): Execution;
+    get rootState(): ExecutionState;
+    isStopped(): boolean;
+    isPaused(): boolean;
+    checkStateAndPause(): Promise<void>;
+    skip(entity: TestableEntityState): void;
+    schedule(entity: TestableEntityState, inputs?: IDynamicValue[], client?: IExecutionClient): Promise<IExecutionResult | null>;
+    mergeExernalValuesWithInternalInputs(externalValues: IDynamicValue[], entity: EntityState): IDynamicValue[];
+    inheritValuesFromContext(context: IValueResolutionContext): void;
+    executeInternalCall(entity: InternalCallState, inputs: IDynamicValue[], project: ProjectState, client?: IExecutionClient): Promise<IExecutionResult>;
+    static executeOperation(operation: OperationState, inputs: IDynamicValue[], project: ProjectState, execution?: Execution): Promise<IExecutionResult>;
+    executeSearch(entity: SearchState, inputs: IDynamicValue[], project: ProjectState): Promise<IExecutionResult>;
+    executeLoop(loop: LoopState, inputs: IDynamicValue[], project: ProjectState, client?: IExecutionClient): Promise<IExecutionResult>;
+    executeFunctionCall(functionCall: FunctionCallState, inputs: IDynamicValue[], project: ProjectState, client?: IExecutionClient): Promise<IExecutionResult>;
+    executeCondition(condition: ConditionState, inputs: IDynamicValue[]): Promise<IExecutionResult>;
+    executeDetachedFullFunctionDeclarationLogic(functionDeclaration: FunctionDeclarationState, inputs: IDynamicValue[], project: ProjectState, client?: IExecutionClient): Promise<IExecutionResult>;
+    executeFullFunctionDeclarationLogic(functionDeclaration: FunctionDeclarationState, inputs: IDynamicValue[], client?: IExecutionClient): Promise<IExecutionResult>;
+    static executeEntryPointEntity(entryPointEntity: EntryPointEntityState, inputs: IDynamicValue[], execution?: Execution): Promise<IExecutionResult>;
+    executeReturnStatement(entity: ReturnStatementState, inputs: IDynamicValue[]): Promise<IExecutionResult>;
+    executeContinueStatement(entity: ContinueStatementState, inputs: IDynamicValue[]): Promise<IExecutionResult>;
+    executeBreakStatement(entity: BreakStatementState, inputs: IDynamicValue[]): Promise<IExecutionResult>;
+    executeVariable(entity: VariableState, inputs: IDynamicValue[]): Promise<IExecutionResult>;
+    mergeValues(inputs: IDynamicValue[], defaultValues: IDynamicValue[]): IDynamicValue[];
+    executeEntity(entity: ExecutableEntityState, inputs?: IDynamicValue[], client?: IExecutionClient): Promise<IExecutionResult>;
+    storeLastExecutionValues(result: IExecutionResult): void;
+    executeBranch(localEntryPoint: TestableEntityState, client?: IExecutionClient, values?: IDynamicValue[]): Promise<IExecutionResult | null>;
+    execute(client?: IExecutionClient, values?: IDynamicValue[]): Promise<IExecutionResult>;
+    getExecutionLevels(): string;
+    logBeforeExecution(methodName: string, entity: EntityState, inputs: IDynamicValue[]): void;
+    addEntity(entity: TestableEntityState): void;
+    addEntityAsync(entity: TestableEntityState, options?: YieldOptions & {
+        skipValidate?: boolean;
+        skipRender?: boolean;
+        skipNotify?: boolean;
+    }): Promise<void>;
+    addEntities(entities: TestableEntityState[]): void;
+    addEntitiesAsync(entities: TestableEntityState[], options?: YieldOptions & {
+        skipValidate?: boolean;
+        skipRender?: boolean;
+        skipNotify?: boolean;
+    }): Promise<void>;
+    removeEntity(entity: TestableEntityState): void;
+    hasEntity(entity: EntityState): boolean;
+    removeScheduled(entity: TestableEntityState): void;
+    hasScheduled(entity: TestableEntityState): boolean;
+    hasSkipped(entity: TestableEntityState): boolean;
+    hasExecuted(entity: TestableEntityState): boolean;
+    hasEntityWithId(id: string): boolean;
+    onAddToSkippedList(callback: (entity: TestableEntityState, options?: YieldOptions & {
+        skipValidate?: boolean;
+        skipRender?: boolean;
+        skipNotify?: boolean;
+    }) => Promise<void> | void): void;
+    onAbortExecution(callback: (entity: TestableEntityState, options?: YieldOptions & {
+        skipValidate?: boolean;
+        skipRender?: boolean;
+        skipNotify?: boolean;
+    }) => Promise<void> | void): void;
+    onAddEntity(callback: (entity: TestableEntityState, options?: YieldOptions & {
+        skipValidate?: boolean;
+        skipRender?: boolean;
+        skipNotify?: boolean;
+    }) => Promise<void> | void): void;
+    onRemoveFromSkippedList(callback: (entity: TestableEntityState, options?: YieldOptions & {
+        skipValidate?: boolean;
+        skipRender?: boolean;
+        skipNotify?: boolean;
+    }) => Promise<void> | void): void;
+    onRemoveEntity(callback: (entity: TestableEntityState, options?: YieldOptions & {
+        skipValidate?: boolean;
+        skipRender?: boolean;
+        skipNotify?: boolean;
+    }) => Promise<void> | void): void;
+    addToExecutingList(entity: TestableEntityState): void;
+    addToScheduledList(entity: TestableEntityState): void;
+    removeFromScheduledList(entity: TestableEntityState): void;
+    removeFromExecutingList(entity: TestableEntityState): void;
+    removeFromAlreadyExecutedList(entity: TestableEntityState): void;
+    removeFromSkippedList(entity: TestableEntityState): void;
+    addToAlreadyExecutedList(entity: TestableEntityState): void;
+    addToSkippedList(entity: TestableEntityState): void;
+    getValueTypePreference(valueOwnerId: EntityId): DynamicValueTypes.DefaultValue | DynamicValueTypes.Testing | null;
+    setValueTypePreference(valueOwnerId: EntityId, valueTypePreference: DynamicValueTypes.DefaultValue | DynamicValueTypes.Testing | null): void;
+}

package/dist/editor/extensions/contexts/base.d.ts

@@ -0,0 +1,21 @@
+import { EventCallback, EventCallbackArguments, IEventsBus } from '@elyx-code/common-ts-utils';
+import { ExtensionsRegistry } from '../registry';
+import { ExtensionContextType } from '../module/extensions';
+
+export interface IExtensionContextBase extends Omit<IEventsBus, 'destroy'> {
+    extensionsRegistry: ExtensionsRegistry;
+}
+export declare class ExtensionContextBase<CT = ExtensionContextType> implements IExtensionContextBase {
+    readonly extensionsRegistry: ExtensionsRegistry;
+    readonly contextType: CT;
+    constructor(extensionsRegistry: ExtensionsRegistry, contextType: CT);
+    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>[]>;
+}

package/dist/editor/extensions/contexts/compiler-context.d.ts

@@ -0,0 +1,5 @@
+import { ExtensionContextType } from '../module';
+import { ExtensionContextBase } from './base';
+
+export interface ICompilerContext extends ExtensionContextBase<ExtensionContextType.Compile> {
+}

package/dist/editor/extensions/contexts/editor-context.d.ts

@@ -0,0 +1,85 @@
+import { IActiveBranchHeadResult, IBranch, ICanvasCopyPayload, IChannelConnections, IEditor, IEnvConfig } from '../../editor';
+import { ExtensionContextBase } from './base';
+import { ExtensionsRegistry } from '../registry';
+import { ExtensionContextType } from '../module';
+import { CanvasEntityState, ChangeSet, EntityWithValueState, PersistChangeSetEntityActionRequestPayload, ProjectState } from '../../../tree';
+import { EntityId } from '../../../definitions';
+import { ITest } from '../../test';
+import { DynamicValueTypes, EfimeralValueStore, IDynamicValue } from '../../value-store';
+import { PublicationRun } from '../../publication';
+import { Execution, TestableEntityState } from '../../execution';
+import { InfrastructureResource, IPublication, IRichProjectRoleDTO, IWorkspace } from '@elyx-code/definitions';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export interface IEditorContext extends ExtensionContextBase<ExtensionContextType.Editor>, Omit<IEditor, 'onLogicLoadingComplete' | 'onLogicLoadingCompleteCallback' | 'onProjectHeadLoaded' | 'onProjectHeadLoadedCallback' | 'onProjectSetupError' | 'onProjectSetupErrorCallback' | 'onRenderedCallback' | 'handleIncommingWebsocketMessage' | 'handleNotificationChannelsMessage' | 'handlePersistChangeSetMessage' | 'handleReconnectingWebsocket' | 'handleChunkedChangeSetMessage' | 'getLogic' | 'injectLocalImplementationOfSearchExecution' | 'setup' | 'destroy' | 'requestExtension' | 'socket' | 'events' | 'initRegistry' | 'extensionsRegistry' | 'on' | 'emit' | 'off' | 'contextType' | 'registerNonDefaultLocalImplementationsOfModules'> {
+}
+export declare class DefaultEditorContext extends ExtensionContextBase<ExtensionContextType.Editor> implements IEditorContext {
+    private readonly _editor;
+    readonly id: string;
+    constructor(extensionsRegistry: ExtensionsRegistry, _editor: IEditor, id?: string);
+    get ready(): boolean;
+    get env(): IEnvConfig;
+    get hasLoadedLogic(): boolean;
+    get destroyed(): boolean;
+    get logicLoadingPromise(): Promise<void> | null;
+    get logic(): ProjectState | null;
+    get lastPublishedProjectState(): ProjectState | null;
+    get branchHead(): IActiveBranchHeadResult | null;
+    get branchHeadPromise(): Promise<IActiveBranchHeadResult | null> | null;
+    get projectId(): EntityId;
+    get sessionId(): string | null;
+    get userAuthorId(): string;
+    get peerConnections(): Record<string, IChannelConnections>;
+    get test(): ITest | null;
+    get localTestValues(): EfimeralValueStore;
+    get resolvedValues(): EfimeralValueStore;
+    get persistedExecutionResults(): EfimeralValueStore;
+    get publication(): PublicationRun | null;
+    get livePublishedVersions(): IPublication[];
+    get publications(): PublicationRun[];
+    get liveResources(): InfrastructureResource[] | null;
+    get execution(): Execution | null;
+    get project(): ProjectState;
+    get lastExecutionResults(): EfimeralValueStore;
+    get undoableStackValueIndex(): number;
+    set undoableStackValueIndex(value: number);
+    get activeWorkspace(): IWorkspace;
+    get branches(): IBranch[];
+    get roles(): IRichProjectRoleDTO[];
+    get READ_ONLY(): boolean;
+    get isViewingNonHead(): boolean;
+    get canEdit(): boolean;
+    get PROJECT_NOTIFICATIONS_CHANNEL(): string;
+    getAccessToken(): Promise<string | null>;
+    getRefreshToken(): Promise<string | null>;
+    removeValueByOwnerId(entityId: EntityId): void;
+    removeValue(dynamicValue: IDynamicValue): void;
+    undo(): Promise<void>;
+    redo(): 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>;
+    loadGivenPublication(publicationId: string): Promise<IPublication>;
+    validateProjectState(options?: YieldOptions): Promise<void>;
+    requestActiveDynamicValue(valueOwner: EntityWithValueState, onlyDefault?: boolean): IDynamicValue | null;
+    getValueTypePreference(valueOwnerId: EntityId): DynamicValueTypes.DefaultValue | DynamicValueTypes.Testing | null;
+    setValueTypePreference(valueOwnerId: EntityId, valueTypePreference: DynamicValueTypes.DefaultValue | DynamicValueTypes.Testing | null): void;
+    implementFeature(featureId: string): Promise<PersistChangeSetEntityActionRequestPayload>;
+    getProjectRoles(): Promise<IRichProjectRoleDTO[]>;
+    getLastPublishedVersionLogic(options: {
+        version: string;
+        branchId: string;
+    }): Promise<ProjectState | null>;
+    initialLoads(options: {
+        mockLogic?: ProjectState | undefined;
+    }): Promise<void>;
+    moveBranchHeadToVersion(versionId: string, actionName: string, overrideReadOnly?: boolean): Promise<IActiveBranchHeadResult | null>;
+    loadInitialBranchHead(): Promise<IActiveBranchHeadResult | null>;
+}
+export declare function toEditorContext(extensionsRegistry: ExtensionsRegistry, editor: IEditor): DefaultEditorContext;

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

@@ -0,0 +1,15 @@
+import { ICompilerContext } from './compiler-context';
+import { DefaultEditorContext, IEditorContext } from './editor-context';
+import { DefaultProjectLogicContext, IProjectLogicContext } from './project-context';
+import { DefaultPublicationRunContext, IPublicationRunContext } from './publication-context';
+
+export { ExtensionContextBase } from './base';
+export { DefaultProjectLogicContext, toProjectLogicContext, } from './project-context';
+export { DefaultEditorContext, toEditorContext } from './editor-context';
+export type { IEditorContext } from './editor-context';
+export type { IProjectLogicContext } from './project-context';
+export type { ICompilerContext } from './compiler-context';
+export type { IPublicationRun, IPublicationRunContext, } from './publication-context';
+export { DefaultPublicationRunContext, toPublicationRunContext, } from './publication-context';
+export type DefaultExtensionContext = DefaultEditorContext | DefaultProjectLogicContext | DefaultPublicationRunContext;
+export type IExtensionContext = IEditorContext | IProjectLogicContext | ICompilerContext | IPublicationRunContext;

package/dist/editor/extensions/contexts/project-context.d.ts

@@ -0,0 +1,152 @@
+import { Element, ElementGenerationTarget, ElementShallowTransfer, ElementTransfer, EntityId, EntityType, EntityVersion, ICondition, IDefinitionEntity, IFunctionCall, IFunctionDeclaration, IGlobalEvent, IInstalledProject, ILoop, IOperation, IProject, IProject_meta, IProjectGenerationTarget, IProjectReference, IProjectShallowTransfer, IProjectTransfer, ISearch, IVariableDeclaration, IVariableInstance, Reference, UserManagedElementShallowTransfer } from '../../../definitions';
+import { ExtensionContextBase } from './base';
+import { ActionDescriptorState, BuiltInBaseEntityState, ChangeSet, ConditionState, DataTypeState, DefinitionEntityState, EntityError, EntityState, EntityWithValueState, EntryPointEntityState, FunctionCallState, FunctionDeclarationState, GlobalEventState, IChangeSet, IEntityJSONCloneOptions, IEntityRecursionOptions, InstalledProjectState, IProjectVersionTransitionConfig, LoopState, OperationState, PersistChangeSetEntityActionRequestPayload, PrimitiveEntityState, ProjectState, SearchState, TerminationEntityState, UserManagedEntityState, ValueDescriptorState, VariableDeclarationState, VariableInstanceState, VariableState } from '../../../tree';
+import { ExtensionsRegistry } from '../registry';
+import { IDynamicValue } from '../../value-store';
+import { ExtensionContextType } from '../module/extensions';
+
+export interface IProjectLogicContext extends ExtensionContextBase<ExtensionContextType.Logic>, IProject {
+}
+export declare class DefaultProjectLogicContext extends ExtensionContextBase<ExtensionContextType.Logic> implements IProjectLogicContext {
+    private readonly _project;
+    constructor(extensionsRegistry: ExtensionsRegistry, _project: ProjectState);
+    readonly id: EntityId;
+    get type(): EntityType.Project;
+    get name(): string | null;
+    get workspaceId(): string;
+    get description(): string | null;
+    get version(): string;
+    get createdAt(): string;
+    get previousVersion(): string | null;
+    get author(): string;
+    get deleted(): boolean;
+    get editable(): boolean;
+    get deletable(): boolean;
+    get entities(): DefinitionEntityState[];
+    get projects(): InstalledProjectState[];
+    get functions(): FunctionDeclarationState[];
+    get events(): GlobalEventState[];
+    get variableDeclarations(): VariableDeclarationState[];
+    get variableInstances(): VariableInstanceState[];
+    get conditions(): ConditionState[];
+    get operations(): OperationState[];
+    get functionCalls(): FunctionCallState[];
+    get loops(): LoopState[];
+    get searches(): SearchState[];
+    get primitives(): PrimitiveEntityState[];
+    get builtInBaseEntities(): BuiltInBaseEntityState[];
+    get operationDeclarations(): ActionDescriptorState[];
+    get globalEventActionDescriptors(): ActionDescriptorState[];
+    get loopDeclarations(): ActionDescriptorState[];
+    get loopDeclarationsBodies(): ActionDescriptorState[];
+    get conditionDeclarations(): ActionDescriptorState[];
+    get valueDescriptors(): ValueDescriptorState[];
+    get dataTypes(): DataTypeState[];
+    get errors(): EntityError[];
+    get history(): ChangeSet[];
+    get undoableStackValueIndex(): number;
+    get knownVersions(): Map<string, EntityState> | null;
+    get activeVersion(): boolean;
+    get initialized(): boolean;
+    get startedInitialization(): boolean;
+    closePersistChangeSetsSequentially(): Promise<void>;
+    persistChangeSetSequentially(changeSet: ChangeSet): Promise<void>;
+    toLatestChangeSet(author: string, timestamp: string, // ISO 8601 format
+    self: UserManagedEntityState | null, autoclose?: boolean, actionName?: string): ChangeSet;
+    addChangeSet(changeSet: ChangeSet): ChangeSet;
+    discardChangeSet(changeSet: ChangeSet): ProjectState;
+    subscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    unsubscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    syncDependents(changeSet?: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRemoved(_dependency: UserManagedEntityState, _field: string, _changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRestored(_dependency: UserManagedEntityState, _field: string, _changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
+    captureVersion(): ProjectState;
+    restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ProjectState>>;
+    updateWithShallowTransfer(transfer: IProjectShallowTransfer, changeSet?: ChangeSet | null): ProjectState;
+    hydrateAncestors(): IChangeSet<ProjectState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<ProjectState>;
+    addSelfToProject(_changeSet: ChangeSet | null): IChangeSet<ProjectState>;
+    get instancesList(): EntityState[];
+    isOperationDeclaration(entity: ActionDescriptorState): boolean;
+    isGlobalEventActionDescriptor(entity: ActionDescriptorState): boolean;
+    isLoopDeclaration(entity: ActionDescriptorState): boolean;
+    isConditionDeclaration(entity: ActionDescriptorState): boolean;
+    findSubscribedBuiltInInstance(entity: Element | ElementTransfer): EntityState | null;
+    get(entityId: EntityId): EntityState | null;
+    getDeleted(entityId: EntityId): EntityState | null;
+    getManaged(entityId: EntityId): EntityState | null;
+    getBuiltIn(entityId: EntityId): EntityState | null;
+    findSubscribedInstanceFromReference(entity: Reference): EntityState | null;
+    findSubscribedBuiltInInstanceFromReference(entity: Reference): EntityState | null;
+    metaSync(changedData: Partial<IProject_meta | IProject | IProjectTransfer | IProjectShallowTransfer>, changeSet?: ChangeSet | null): ProjectState;
+    getAllBuiltInIds(): EntityId[];
+    getAllBuiltIn(): EntityState[];
+    toFlat(seenEntities?: Set<EntityId>): EntityState[];
+    toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
+    toMeta(): IProject_meta;
+    toJSON(seenEntities?: Set<EntityId>): IProjectTransfer | IProjectReference;
+    toJSONClone(options?: IEntityJSONCloneOptions): IProjectTransfer;
+    toReference(options?: IEntityRecursionOptions): IProjectReference;
+    toShallowJSON(options?: IEntityRecursionOptions): IProjectShallowTransfer;
+    toFlatJSON(seenEntities?: Set<EntityId>): ElementShallowTransfer[];
+    toGenerationTarget(options?: IEntityRecursionOptions): IProjectGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<EntityId>): ElementGenerationTarget[];
+    clearErrors(): ProjectState;
+    validate(): {
+        success: boolean;
+    };
+    validateChildren(): void;
+    getErrors(): EntityError[];
+    getShallowErrors(): EntityError[];
+    addDefinitionEntity(entity: DefinitionEntityState): DefinitionEntityState;
+    addFunctionDeclaration(func: FunctionDeclarationState): FunctionDeclarationState;
+    addFunctionCall(func: FunctionCallState): FunctionCallState;
+    addVariableDeclaration(variable: VariableDeclarationState): VariableDeclarationState;
+    addVariableInstance(variable: VariableInstanceState): VariableInstanceState;
+    addInstalledProject(project: InstalledProjectState): ProjectState;
+    addGlobalEvent(event: GlobalEventState): ProjectState;
+    addCondition(condition: ConditionState): ProjectState;
+    addOperation(operation: OperationState): ProjectState;
+    addLoop(loop: LoopState): ProjectState;
+    addSearch(search: SearchState): ProjectState;
+    removeDefinitionEntity(entity: IDefinitionEntity): DefinitionEntityState | null;
+    removeCondition(condition: ICondition): ConditionState | null;
+    removeOperation(operation: IOperation): OperationState | null;
+    removeLoop(loop: ILoop): LoopState | null;
+    removeSearch(search: ISearch): SearchState | null;
+    removeFunctionCall(funcCall: IFunctionCall): FunctionCallState | null;
+    removeVariableInstance(variable: IVariableInstance): VariableInstanceState | null;
+    removeVariableDeclaration(variable: IVariableDeclaration): VariableDeclarationState | null;
+    removeFunctionDeclaration(func: IFunctionDeclaration): FunctionDeclarationState | null;
+    removeInstalledProject(project: IInstalledProject): InstalledProjectState | null;
+    removeGlobalEvent(event: IGlobalEvent): GlobalEventState | null;
+    removeTopLevelVariableDeclaration(variable: VariableDeclarationState): VariableDeclarationState | null;
+    getEntryPoints(): EntryPointEntityState[];
+    getTerminationStatements(): TerminationEntityState[];
+    getFunctionDeclaration(id: EntityId): FunctionDeclarationState | null;
+    getConditions(): ConditionState[];
+    getOperations(): OperationState[];
+    getVariables(): VariableState[];
+    getVariableInstances(): VariableInstanceState[];
+    getVariableDeclarations(): VariableDeclarationState[];
+    getLoops(): LoopState[];
+    getSearches(): SearchState[];
+    getBuiltInPersistedEntity(): BuiltInBaseEntityState | null;
+    requestActiveDynamicValue(valueOwner: EntityWithValueState, onlyDefault?: boolean): IDynamicValue | null;
+    undo(): IProjectVersionTransitionConfig;
+    redo(): IProjectVersionTransitionConfig;
+    applyExternalChangeSet(request: PersistChangeSetEntityActionRequestPayload): ChangeSet;
+    toFullProjectTransfer(): {
+        order: EntityId[];
+        size: number;
+        record: Record<EntityId, UserManagedElementShallowTransfer>;
+    };
+}
+export declare function toProjectLogicContext(extensionsRegistry: ExtensionsRegistry, project: ProjectState): DefaultProjectLogicContext;