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

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

@@ -0,0 +1,361 @@
+import { EntityId, EntityType, IProject, IDefinitionEntity, IFunctionDeclaration, IGlobalEvent, Element, IProjectTransfer, IGenericReference, ElementTransfer, Reference, IProjectReference, IProjectShallowTransfer, ElementShallowTransfer, ElementGenerationTarget, IProjectGenerationTarget, ProjectTypesUnion, EntityVersion, IProject_meta, UserManagedElementShallowTransfer, ICondition, IOperation, ISearch, IFunctionCall, IVariableDeclaration, IVariableInstance, ILoop, IInstalledProject, UserManagedElementGenerationTarget } from '../../../definitions';
+import { UserManagedBaseState, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateTemplate, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
+import { FunctionDeclarationState } from '../function-declaration';
+import { GlobalEventState } from '../global-event';
+import { DefinitionEntityState } from '../definition-entity';
+import { InstalledProjectState } from '../installed-project';
+import { VariableDeclarationState } from '../variable-declaration';
+import { ConditionState } from '../condition';
+import { FunctionCallState } from '../function-call';
+import { OperationState } from '../operation';
+import { PrimitiveEntityState } from '../primitive-entity';
+import { DataTypeState } from '../data-type';
+import { EntityState, EntryPointEntityState, PersistChangeSetEntityActionRequestPayload, VariableState, EntityWithValueState, TerminationEntityState, UserManagedEntityState } from '../types';
+import { ChangeSet, IChangeSet, IProjectVersionTransitionConfig } from '../change-set';
+import { LoopState } from '../loop';
+import { SearchState } from '../search';
+import { VariableInstanceState } from '../variable-instance';
+import { BuiltInBaseEntityState } from '../built-in-base-entity';
+import { EntityError, EntityGenerationError } from '../error';
+import { ActionDescriptorState } from '../action-descriptor';
+import { GenerationExplanationIds } from '../validate';
+import { ValueDescriptorState } from '../value-descriptor';
+import { UserManagedVersionedState } from '../version';
+import { Events, YieldOptions } from '@elyx-code/common-ts-utils';
+import { IUUIDModule } from '../../../uuid';
+import { IDynamicValue } from '../../../editor';
+import { IBaseExtensionsContext } from '../../../editor/extensions';
+
+export declare enum ProjectStateEvents {
+    PROJECT_INITIALIZED = "project-initialized",
+    BEFORE_CHANGE_SET_CLOSE_BEFORE_SIDE_EFFECTS = "before-change-set-close-before-side-effects",
+    BEFORE_CHANGE_SET_CLOSE_AFTER_SIDE_EFFECTS = "before-change-set-close-after-side-effects",
+    CHANGE_SET_CLOSED_BEFORE_PERSIST = "change-set-closed-before-persist",
+    CHANGE_SET_PERSISTED = "change-set-persisted",
+    BEFORE_CHANGE_SET_PERSIST = "before-change-set-persist",
+    EXPLICIT_DEFINITION_ENTITY_ADDED = "explicit-definition-entity-added",
+    EXPLICIT_DEFINITION_ENTITY_REMOVED = "explicit-definition-entity-removed",
+    EXPLICIT_DEFINITION_ENTITY_UPDATED = "explicit-definition-entity-updated",
+    PERSISTED_DEFINITION_ENTITY_ADDED = "persisted-definition-entity-added",
+    PERSISTED_DEFINITION_ENTITY_REMOVED = "persisted-definition-entity-removed",
+    PERSISTED_DEFINITION_ENTITY_UPDATED = "persisted-definition-entity-updated",
+    RELATIONAL_DATABASE_DEFINITION_ENTITY_ADDED = "relational-database-definition-entity-added",
+    RELATIONAL_DATABASE_DEFINITION_ENTITY_REMOVED = "relational-database-definition-entity-removed",
+    RELATIONAL_DATABASE_DEFINITION_ENTITY_UPDATED = "relational-database-definition-entity-updated"
+}
+export interface IProjectStaticParentContext extends IBaseExtensionsContext {
+    events: Events;
+}
+export interface IProjectInstanceParentContext extends IProjectStaticParentContext {
+    requestActiveDynamicValue: (valueOwner: EntityWithValueState, onlyDefault?: boolean) => IDynamicValue | null;
+    events: Events;
+}
+export declare const DEFAULT_PROJECT_STATIC_PARENT_CONTEXT: IProjectStaticParentContext;
+export declare const DEFAULT_PROJECT_INSTANCE_PARENT_CONTEXT: IProjectInstanceParentContext;
+export declare class ProjectState extends UserManagedVersionedState implements IProject, UserManagedEntityStateTemplate, UserManagedBaseState {
+    readonly parentContext: IProjectInstanceParentContext;
+    initialData: IProject | IProjectTransfer;
+    readonly id: EntityId;
+    readonly type: EntityType.Project;
+    readonly workspaceId: string;
+    name: string | null;
+    description: string | null;
+    x: number;
+    y: number;
+    entities: DefinitionEntityState[];
+    projects: InstalledProjectState[];
+    functions: FunctionDeclarationState[];
+    events: GlobalEventState[];
+    variableDeclarations: VariableDeclarationState[];
+    variableInstances: VariableInstanceState[];
+    conditions: ConditionState[];
+    operations: OperationState[];
+    functionCalls: FunctionCallState[];
+    loops: LoopState[];
+    searches: SearchState[];
+    primitives: PrimitiveEntityState[];
+    builtInBaseEntities: BuiltInBaseEntityState[];
+    operationDeclarations: ActionDescriptorState[];
+    globalEventActionDescriptors: ActionDescriptorState[];
+    loopDeclarations: ActionDescriptorState[];
+    loopDeclarationsBodies: ActionDescriptorState[];
+    conditionDeclarations: ActionDescriptorState[];
+    valueDescriptors: ValueDescriptorState[];
+    dataTypes: DataTypeState[];
+    project: ProjectState;
+    instances: {
+        [id: EntityId]: UserManagedEntityState;
+    };
+    builtInInstances: {
+        [id: EntityId]: EntityState;
+    };
+    deletedInstances: {
+        [id: EntityId]: UserManagedEntityState;
+    };
+    subscribedDefinitionEntities: Set<EntityId>;
+    errors: EntityError[];
+    references: IGenericReference[];
+    history: ChangeSet[];
+    undoableStackValueIndex: number;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
+    knownVersions: Map<string, UserManagedEntityState> | null;
+    activeVersion: boolean;
+    initialized: boolean;
+    startedInitialization: boolean;
+    diggestedBuiltInBaseEntitiesIds: Set<EntityId>;
+    rejectParallelCS: boolean;
+    onPersistChangeSetSequentiallyCallback: ((changeSet: ChangeSet) => Promise<{
+        success: boolean;
+    }>) | null;
+    onPersistChangeSetInParallelCallback: ((changeSet: ChangeSet) => Promise<{
+        success: boolean;
+    }>) | null;
+    onAddChangeSetCallback: ((changeSet: ChangeSet, undoableStackValueIndex: number) => void) | null;
+    onDiscardChangeSetCallback: ((changeSet: ChangeSet) => void) | null;
+    constructor(initialData: IProject | IProjectTransfer, parentContext?: IProjectInstanceParentContext);
+    static parentContext: IProjectStaticParentContext;
+    static get UUID(): import('../../../editor').ExtensionModule<IUUIDModule>;
+    static sessionAuthor: string;
+    static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.Project;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
+    static MUTABLE_BASE_PROPERTIES: string[];
+    static INMUTABLE_BASE_PROPERTIES: string[];
+    static BASE_PROPERTIES: string[];
+    static MUTABLE_META_PROPERTIES: string[];
+    static INMUTABLE_META_PROPERTIES: string[];
+    static META_PROPERTIES: string[];
+    static MUTABLE_UPSTREAM_PROPERTIES: string[];
+    static INMUTABLE_UPSTREAM_PROPERTIES: string[];
+    static UPSTREAM_PROPERTIES: string[];
+    static MUTABLE_DOWNSTREAM_PROPERTIES: string[];
+    static INMUTABLE_DOWNSTREAM_PROPERTIES: string[];
+    static DOWNSTREAM_PROPERTIES: string[];
+    static PROPERTIES: string[];
+    static new(changeSet?: ChangeSet | null): IProjectTransfer;
+    static validateGenerationTarget(data: IProjectGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: IProjectGenerationTarget;
+    };
+    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'];
+    closePersistChangeSetsSequentially(): Promise<void>;
+    onPersistChangeSetSequentially(callback: (changeSet: ChangeSet) => Promise<{
+        success: boolean;
+    }>): Promise<void>;
+    offPersistChangeSetSequentially(): void;
+    onPersistChangeSetInParallel(callback: (changeSet: ChangeSet) => Promise<{
+        success: boolean;
+    }>): Promise<void>;
+    offPersistChangeSetInParallel(): void;
+    onAddChangeSet(callback: (changeSet: ChangeSet, undoableStackValueIndex: number) => void): void;
+    offAddChangeSet(): void;
+    onDiscardChangeSet(callback: (changeSet: ChangeSet) => void): void;
+    offDiscardChangeSet(): void;
+    persistChangeSetSequentially(changeSet: ChangeSet): Promise<void>;
+    persistChangeSetInParallel(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;
+    validateGeneratedUpdate(data: Partial<IProjectGenerationTarget>): {
+        errors: EntityGenerationError[];
+        explanations: {
+            id: GenerationExplanationIds;
+            message: string;
+        }[];
+        modifiedData: Partial<IProjectGenerationTarget>;
+    };
+    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>;
+    unsubscribeFromDependencies(): UserManagedEntityState;
+    subscribeToDependencies(): UserManagedEntityState;
+    increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
+    captureVersion(): ProjectState;
+    snapshot(): ProjectState;
+    /**
+     * Given an instance of the same entity class type,
+     * it applies the current entity state to it by copying all of its data and entity references
+     *
+     * @param {ProjectState} snapshotInstance
+     * @returns {ProjectState} The snapshot instance with the current entity state applied to it
+     */
+    apply(snapshotInstance: ProjectState): ProjectState;
+    recursiveCaptureUpstreamVersions(_sharedTimestamp: null | string): IChangeSet<ProjectState>;
+    restoreVersion(versionId: EntityVersion, options?: {
+        skipIfSameVersion?: boolean;
+    }): Promise<IChangeSet<ProjectState>>;
+    updateWithShallowTransfer(transfer: IProjectShallowTransfer, changeSet?: ChangeSet | null): ProjectState;
+    updateWithGenerationTarget(transfer: Partial<IProjectGenerationTarget>, changeSet?: ChangeSet | null): ProjectState;
+    hydrateAncestors(): IChangeSet<ProjectState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<ProjectState>;
+    addSelfToProject(_changeSet: ChangeSet | null): IChangeSet<ProjectState>;
+    get instancesList(): EntityState[];
+    get builtInInstancesList(): EntityState[];
+    isOperationDeclaration(entity: ActionDescriptorState): boolean;
+    isGlobalEventActionDescriptor(entity: ActionDescriptorState): boolean;
+    isLoopDeclaration(entity: ActionDescriptorState): boolean;
+    isConditionDeclaration(entity: ActionDescriptorState): boolean;
+    initChildren(changeSet?: ChangeSet | null): ProjectState;
+    subscribeInstance(instance: UserManagedEntityState): ProjectState;
+    subscribeDeletedInstance(instance: UserManagedEntityState): ProjectState;
+    subscribeBuiltInInstance(instance: EntityState): ProjectState;
+    subscribe(): ProjectState;
+    unsubscribe(): ProjectState;
+    unsubscribeInstance(entity: EntityState): ProjectState;
+    unsubscribeDeletedInstance(entity: EntityState): ProjectState;
+    unsubscribeBuiltInInstance(entity: EntityState): ProjectState;
+    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 & {
+        x: number;
+        y: number;
+    }) | (IProject & {
+        x: number;
+        y: number;
+    }) | (IProjectTransfer & {
+        x: number;
+        y: number;
+    }) | (IProjectShallowTransfer & {
+        x: number;
+        y: number;
+    })>, changeSet?: ChangeSet | null): ProjectState;
+    APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ProjectState>;
+    APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ProjectState>;
+    APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ProjectState>;
+    APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ProjectState>;
+    APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ProjectState>;
+    APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IProjectShallowTransfer | null>;
+    remove({ ignoreUpstream: _ }?: {
+        ignoreUpstream: boolean;
+    }, _changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, _changeSet?: ChangeSet | null): IChangeSet<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;
+    };
+    validateAsync(options?: YieldOptions): Promise<{
+        success: boolean;
+    }>;
+    validateChildren(): void;
+    validateChildrenAsync(options?: YieldOptions): Promise<void>;
+    getErrors(): EntityError[];
+    getErrorsAsync(options?: YieldOptions): Promise<EntityError[]>;
+    getShallowErrors(): EntityError[];
+    clone(): ProjectState;
+    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[];
+    getFunctionCalls(): FunctionCallState[];
+    getDefinitionEntities(except?: Set<EntityId>): DefinitionEntityState[];
+    getVariables(): VariableState[];
+    getVariableInstances(): VariableInstanceState[];
+    getVariableDeclarations(): VariableDeclarationState[];
+    getLoops(): LoopState[];
+    getSearches(): SearchState[];
+    attachOrphanReferences(): ProjectState;
+    getBuiltInPersistedEntity(): BuiltInBaseEntityState | null;
+    requestActiveDynamicValue(valueOwner: EntityWithValueState, onlyDefault?: boolean): IDynamicValue | null;
+    requestExtension<T = any>(moduleId: string): T | null;
+    undo(): IProjectVersionTransitionConfig;
+    redo(): IProjectVersionTransitionConfig;
+    applyExternalChangeSet(request: PersistChangeSetEntityActionRequestPayload): ChangeSet;
+    toBuiltInShallowRecord(): Record<EntityId, ElementShallowTransfer>;
+    toShallowRecord(): Record<EntityId, UserManagedElementShallowTransfer>;
+    toFullProjectTransfer(options?: {
+        shallowErrors?: boolean;
+    }): {
+        order: EntityId[];
+        size: number;
+        record: Record<EntityId, UserManagedElementShallowTransfer>;
+    };
+    toFullProjectTransferAsync(options?: YieldOptions & {
+        seenEntityMaps?: Map<EntityId, EntityId>;
+        resetVersionOptions?: {
+            commonTimestamp?: string;
+            author?: string;
+        };
+        onVisit?: (entity: UserManagedElementShallowTransfer) => Promise<void>;
+        shallowErrors?: boolean;
+    }): Promise<{
+        order: EntityId[];
+        size: number;
+        record: Record<EntityId, UserManagedElementShallowTransfer>;
+    }>;
+    toFullProjectGenerationTargetAsync(options?: YieldOptions & {
+        seenEntityMaps?: Map<EntityId, EntityId>;
+        onVisit?: (entity: UserManagedElementGenerationTarget) => Promise<void>;
+        shallowErrors?: boolean;
+    }): Promise<{
+        order: EntityId[];
+        size: number;
+        record: Record<EntityId, UserManagedElementGenerationTarget>;
+    }>;
+}
+export type ProjectPayloadUnion = ProjectState | ProjectTypesUnion;

package/dist/tree/state/project/project.part1.test-process.d.ts

@@ -0,0 +1 @@
+export {};