@elyx-code/project-logic-tree 0.0.1

package/dist/tree/state/installed-project/index.d.ts

@@ -0,0 +1 @@
+export * from './installed-project';

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

@@ -0,0 +1,90 @@
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IInstalledProject, IInstalledProjectGenerationTarget, IInstalledProjectReference, IInstalledProjectShallowTransfer, IInstalledProjectTransfer, IProjectReference, InstalledProjectTypesUnion } from '../../../../../../../../../src/definitions';
+import { ZodError } from 'zod';
+import { BaseCanvasDraggableState, BaseState, ChildEntityState, UserManagedEntityStateFunctionality } from '../base';
+import { FunctionDeclarationState } from '../function-declaration';
+import { GlobalEventState } from '../global-event';
+import { ProjectState } from '../project/project';
+import { EntityError, EntityGenerationError } from '../error';
+import { EntityState } from '../types';
+
+export declare class InstalledProjectState implements IInstalledProject, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, ChildEntityState {
+    initialData: IInstalledProject | IInstalledProjectTransfer;
+    readonly id: EntityId;
+    readonly version: EntityVersion;
+    readonly name: string;
+    readonly description: string | null;
+    x: number;
+    y: number;
+    readonly type: EntityType.InstalledProject;
+    implements: IProjectReference;
+    functions: FunctionDeclarationState[];
+    events: GlobalEventState[];
+    parent: ProjectState;
+    errors: EntityError[];
+    project: ProjectState;
+    initialized: boolean;
+    constructor(initialInstalledProjectData: IInstalledProject | IInstalledProjectTransfer, parentProjectState: ProjectState);
+    static MUTABLE_BASE_PROPERTIES: string[];
+    static INMUTABLE_BASE_PROPERTIES: string[];
+    static BASE_PROPERTIES: string[];
+    static MUTABLE_META_PROPERTIES: string[];
+    static INMUTABLE_META_PROPERTIES: string[];
+    static META_PROPERTIES: string[];
+    static MUTABLE_UPSTREAM_PROPERTIES: string[];
+    static INMUTABLE_UPSTREAM_PROPERTIES: string[];
+    static UPSTREAM_PROPERTIES: string[];
+    static MUTABLE_DOWNSTREAM_PROPERTIES: string[];
+    static INMUTABLE_DOWNSTREAM_PROPERTIES: string[];
+    static DOWNSTREAM_PROPERTIES: string[];
+    static PROPERTIES: string[];
+    static fromGenerationTarget(data: IInstalledProjectGenerationTarget, parentProjectState: ProjectState): InstalledProjectState;
+    static validateGenerationTarget(data: IInstalledProjectGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        modifiedData: IInstalledProjectGenerationTarget;
+    };
+    validateGeneratedUpdate(data: Partial<IInstalledProjectGenerationTarget>): {
+        errors: EntityGenerationError[];
+        modifiedData: Partial<IInstalledProjectGenerationTarget>;
+    };
+    addSelfToProject(): InstalledProjectState;
+    setParent(parent: ProjectState): InstalledProjectState;
+    initChildren(): InstalledProjectState;
+    subscribe(): InstalledProjectState;
+    unsubscribe(): InstalledProjectState;
+    sync(data: Partial<IInstalledProject>): InstalledProjectState;
+    load(): Promise<InstalledProjectState>;
+    create(): Promise<InstalledProjectState>;
+    update(_: Partial<InstalledProjectTypesUnion>): Promise<InstalledProjectState>;
+    delete(): Promise<InstalledProjectState>;
+    remove({ ignoreUpstream: _, seenEntities, }?: {
+        ignoreUpstream: boolean;
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        removed: EntityState[];
+    };
+    restore({ seenEntities }?: {
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        self: InstalledProjectState;
+    };
+    toFlat(seenEntities?: Set<string>): EntityState[];
+    toFlatIds(seenEntities?: Set<string>): EntityId[];
+    toJSON(): IInstalledProjectTransfer;
+    toReference(): IInstalledProjectReference;
+    toShallowJSON(): IInstalledProjectShallowTransfer;
+    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toGenerationTarget(): IInstalledProjectGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    clearErrors(): InstalledProjectState;
+    validate(): {
+        success: boolean;
+        error: ZodError | null;
+        data: IInstalledProjectTransfer | null;
+    };
+    getErrors(): EntityError[];
+    getShallowErrors(): EntityError[];
+    clone(): InstalledProjectState;
+}
+export type InstalledProjectPayloadUnion = InstalledProjectState | InstalledProjectTypesUnion;

package/dist/tree/state/installed-project/validation/logic-validation.d.ts

@@ -0,0 +1,4 @@
+import { EntityError } from '../../error';
+import { InstalledProjectState } from '../installed-project';
+
+export declare function validate(self: InstalledProjectState): EntityError[];

package/dist/tree/state/installed-project/validation/validation-schema.d.ts

@@ -0,0 +1,238 @@
+import { EntityType } from '../../../../../../../../../../src/definitions';
+import { z } from 'zod';
+
+export declare function getInstalledProjectTypeSchema(): z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.InstalledProject>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.InstalledProject;
+}, {
+    type: EntityType.InstalledProject;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+export declare function getInstalledProjectReferenceSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.GenericReference>;
+    entityId: z.ZodString;
+    entityType: z.ZodLiteral<EntityType.InstalledProject>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: EntityType.GenericReference;
+    entityType: EntityType.InstalledProject;
+    entityId: string;
+}, {
+    id: string;
+    type: EntityType.GenericReference;
+    entityType: EntityType.InstalledProject;
+    entityId: string;
+}>;
+export declare function getInstalledProjectBaseSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.InstalledProject>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: EntityType.InstalledProject;
+}, {
+    id: string;
+    type: EntityType.InstalledProject;
+}>;
+export declare function getInstalledProjectMetaSchema(): z.ZodObject<{
+    version: z.ZodNumber;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    version: number;
+    x: number;
+    y: number;
+}, {
+    version: number;
+    x: number;
+    y: number;
+}>;
+export declare function getInstalledProjectGenerationTargetSchema(): z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare function getInstalledProjectNestedEntitiesSchema(): z.ZodObject<{
+    implements: z.ZodObject<{
+        entityType: z.ZodLiteral<EntityType.Project>;
+        entityId: z.ZodString;
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    }, {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    }>;
+    description: z.ZodNullable<z.ZodString>;
+    functions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.FunctionDeclaration>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.FunctionDeclaration;
+    }, {
+        type: EntityType.FunctionDeclaration;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    events: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.GlobalEvent>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GlobalEvent;
+    }, {
+        type: EntityType.GlobalEvent;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    parent: z.ZodObject<{
+        entityType: z.ZodLiteral<EntityType.Project>;
+        entityId: z.ZodString;
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    }, {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    description: string | null;
+    implements: {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    parent: {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+}, {
+    description: string | null;
+    implements: {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    parent: {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+}>;
+export declare function getInstalledProjectSchema(): z.ZodObject<z.objectUtil.extendShape<{
+    version: z.ZodNumber;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, {
+    implements: z.ZodObject<{
+        entityType: z.ZodLiteral<EntityType.Project>;
+        entityId: z.ZodString;
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    }, {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    }>;
+    description: z.ZodNullable<z.ZodString>;
+    functions: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.FunctionDeclaration>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.FunctionDeclaration;
+    }, {
+        type: EntityType.FunctionDeclaration;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    events: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.GlobalEvent>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.GlobalEvent;
+    }, {
+        type: EntityType.GlobalEvent;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    parent: z.ZodObject<{
+        entityType: z.ZodLiteral<EntityType.Project>;
+        entityId: z.ZodString;
+        id: z.ZodString;
+        type: z.ZodLiteral<EntityType.GenericReference>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    }, {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    }>;
+}>, "strip", z.ZodTypeAny, {
+    description: string | null;
+    implements: {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    parent: {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    version: number;
+    x: number;
+    y: number;
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+}, {
+    description: string | null;
+    implements: {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    parent: {
+        id: string;
+        type: EntityType.GenericReference;
+        entityType: EntityType.Project;
+        entityId: string;
+    };
+    version: number;
+    x: number;
+    y: number;
+    functions: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    events: (Record<string, any> | {
+        type: EntityType.GlobalEvent;
+    })[];
+}>;

package/dist/tree/state/internal-call/index.d.ts

@@ -0,0 +1 @@
+export * from './internal-call';

package/dist/tree/state/internal-call/internal-call.d.ts

@@ -0,0 +1,109 @@
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IInternalCall, IInternalCallGenerationTarget, IInternalCallReference, IInternalCallShallowTransfer, IInternalCallTransfer, InternalCallTypesUnion } from '../../../../../../../../../src/definitions';
+import { ZodError } from 'zod';
+import { BaseState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass, UserManagedEntityStateFunctionality } from '../base';
+import { ActionInputMapState } from '../input-map';
+import { ActionOutputMapState } from '../output-map';
+import { CallableEntityState, CallerEntityState, EntityState, EntryPointEntityState, PassThroughCallableEntityState, ValueReadingEntityState, VariableState } from '../types';
+import { ProjectState } from '../project/project';
+import { FunctionDeclarationState } from '../function-declaration';
+import { EntityError, EntityGenerationError } from '../error';
+
+export declare class InternalCallState implements IInternalCall, UserManagedEntityStateFunctionality, BaseState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
+    initialData: IInternalCall | IInternalCallTransfer;
+    readonly id: EntityId;
+    version: EntityVersion;
+    index: number;
+    readonly type: EntityType.InternalCall;
+    declaration: FunctionDeclarationState;
+    inputs: ActionInputMapState[];
+    outputs: ActionOutputMapState[];
+    process: ActionOutputMapState | null;
+    successCalls: CallableEntityState[];
+    errorCalls: CallableEntityState[];
+    error: ActionOutputMapState | null;
+    calledBySuccess: PassThroughCallableEntityState[];
+    calledByError: PassThroughCallableEntityState[];
+    calledByEntry: EntryPointEntityState[];
+    parent: VariableState;
+    project: ProjectState;
+    errors: EntityError[];
+    initialized: boolean;
+    constructor(initialOperationData: IInternalCall | IInternalCallTransfer, parentProjectState: ProjectState);
+    static MUTABLE_BASE_PROPERTIES: string[];
+    static INMUTABLE_BASE_PROPERTIES: string[];
+    static BASE_PROPERTIES: string[];
+    static MUTABLE_META_PROPERTIES: string[];
+    static INMUTABLE_META_PROPERTIES: string[];
+    static META_PROPERTIES: string[];
+    static MUTABLE_UPSTREAM_PROPERTIES: string[];
+    static INMUTABLE_UPSTREAM_PROPERTIES: string[];
+    static UPSTREAM_PROPERTIES: string[];
+    static MUTABLE_DOWNSTREAM_PROPERTIES: string[];
+    static INMUTABLE_DOWNSTREAM_PROPERTIES: string[];
+    static DOWNSTREAM_PROPERTIES: string[];
+    static PROPERTIES: string[];
+    static fromGenerationTarget(data: IInternalCallGenerationTarget, parentProjectState: ProjectState): InternalCallState;
+    static validateGenerationTarget(data: IInternalCallGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        modifiedData: IInternalCallGenerationTarget;
+    };
+    validateGeneratedUpdate(data: Partial<IInternalCallGenerationTarget>): {
+        errors: EntityGenerationError[];
+        modifiedData: Partial<IInternalCallGenerationTarget>;
+    };
+    addSelfToProject(): InternalCallState;
+    get calledBy(): CallerEntityState[];
+    removeInput(input: ActionInputMapState): InternalCallState;
+    addInput(input: ActionInputMapState): InternalCallState;
+    addOutput(output: ActionOutputMapState): InternalCallState;
+    removeOutput(output: ActionOutputMapState): InternalCallState;
+    addValueReader(entity: ValueReadingEntityState): InternalCallState;
+    removeValueReader(valueReader: ValueReadingEntityState): InternalCallState;
+    addSuccessCaller(caller: PassThroughCallableEntityState): InternalCallState;
+    addErrorCaller(caller: PassThroughCallableEntityState): InternalCallState;
+    addEntryCaller(caller: EntryPointEntityState): InternalCallState;
+    addErrorCall(call: CallableEntityState): InternalCallState;
+    addSuccessCall(call: CallableEntityState): InternalCallState;
+    removeCall(call: CallableEntityState): InternalCallState;
+    removeCaller(caller: CallerEntityState): InternalCallState;
+    setParent(parent: VariableState): InternalCallState;
+    initChildren(): InternalCallState;
+    subscribe(): InternalCallState;
+    unsubscribe(): InternalCallState;
+    sync(data: Partial<IInternalCall>): InternalCallState;
+    load(): Promise<InternalCallState>;
+    create(): Promise<InternalCallState>;
+    update(_: Partial<InternalCallTypesUnion>): Promise<InternalCallState>;
+    delete(): Promise<InternalCallState>;
+    remove({ ignoreUpstream, seenEntities, }?: {
+        ignoreUpstream: boolean;
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        removed: EntityState[];
+    };
+    restore({ seenEntities }?: {
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        self: InternalCallState;
+    };
+    toFlat(seenEntities?: Set<string>): EntityState[];
+    toFlatIds(seenEntities?: Set<string>): EntityId[];
+    toJSON(): IInternalCallTransfer;
+    toReference(): IInternalCallReference;
+    toShallowJSON(): IInternalCallShallowTransfer;
+    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toGenerationTarget(): IInternalCallGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    clearErrors(): InternalCallState;
+    validate(): {
+        success: boolean;
+        error: ZodError | null;
+        data: IInternalCallTransfer | null;
+    };
+    getErrors(): EntityError[];
+    getShallowErrors(): EntityError[];
+    clone(_?: EntryPointEntityState): InternalCallState;
+}
+export type InternalCallPayloadUnion = InternalCallState | InternalCallTypesUnion;

package/dist/tree/state/internal-call/validation/logic-validation.d.ts

@@ -0,0 +1,4 @@
+import { EntityError } from '../../error';
+import { InternalCallState } from '../internal-call';
+
+export declare function validate(self: InternalCallState): EntityError[];