@elyx-code/project-logic-tree 0.0.1

package/dist/tree/state/primitive-entity/index.d.ts

@@ -0,0 +1 @@
+export * from './primitive-entity';

package/dist/tree/state/primitive-entity/init.d.ts

@@ -0,0 +1,4 @@
+import { ProjectState } from '../project';
+import { PrimitiveEntityState } from './primitive-entity';
+
+export declare function initAllPrimitiveEntities(project: ProjectState): PrimitiveEntityState[];

package/dist/tree/state/primitive-entity/primitive-entity.d.ts

@@ -0,0 +1,62 @@
+import { EntityId, EntityType, EntityVersion, IPrimitiveEntity, PrimitiveTypes, IPrimitiveEntityTransfer, IPrimitiveEntityReference, IPrimitiveEntityShallowTransfer, ElementShallowTransfer, IPrimitiveEntityGenerationTarget, ElementGenerationTarget, PrimitiveEntityTypesUnion } from '../../../../../../../../../src/definitions';
+import { ZodError } from 'zod';
+import { BaseState } from '../base';
+import { PropertyState } from '../property';
+import { ProjectState } from '../project/project';
+import { BuiltInBaseEntityState } from '../built-in-base-entity';
+import { FunctionDeclarationState } from '../function-declaration';
+import { ActionDescriptorState } from '../action-descriptor';
+import { EntityError } from '../../state/error';
+import { EntityState } from '../types';
+
+export declare class PrimitiveEntityState implements BaseState, IPrimitiveEntity {
+    initialData: IPrimitiveEntity | IPrimitiveEntityTransfer;
+    readonly id: EntityId;
+    readonly version: EntityVersion;
+    readonly name: PrimitiveTypes;
+    readonly description: string | null;
+    readonly type: EntityType.PrimitiveEntity;
+    readonly static: boolean;
+    readonly abstract: boolean;
+    readonly properties: PropertyState[];
+    readonly methods: FunctionDeclarationState[];
+    readonly abstractMethods: ActionDescriptorState[];
+    readonly extends: (PrimitiveEntityState | BuiltInBaseEntityState)[];
+    errors: EntityError[];
+    project: ProjectState;
+    constructor(initialEntityData: IPrimitiveEntity | IPrimitiveEntityTransfer, parentProjectState: ProjectState);
+    subscribe(): PrimitiveEntityState;
+    unsubscribe(): PrimitiveEntityState;
+    load(): Promise<PrimitiveEntityState>;
+    remove({ ignoreUpstream: _, seenEntities: _1, }?: {
+        ignoreUpstream: boolean;
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        removed: EntityState[];
+    };
+    restore({ seenEntities: _ }?: {
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        self: PrimitiveEntityState;
+    };
+    toFlat(seenEntities?: Set<string>): EntityState[];
+    toFlatIds(seenEntities?: Set<string>): EntityId[];
+    toJSON(): IPrimitiveEntityTransfer;
+    toReference(): IPrimitiveEntityReference;
+    toShallowJSON(): IPrimitiveEntityShallowTransfer;
+    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toGenerationTarget(): IPrimitiveEntityGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    clearErrors(): PrimitiveEntityState;
+    validate(): {
+        success: boolean;
+        error: ZodError | null;
+        data: IPrimitiveEntityTransfer | null;
+    };
+    getErrors(): EntityError[];
+    getShallowErrors(): EntityError[];
+    clone(): PrimitiveEntityState;
+}
+export type PrimitiveEntityPayloadUnion = PrimitiveEntityState | PrimitiveEntityTypesUnion;

package/dist/tree/state/primitive-entity/validation/logic-validation.d.ts

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

package/dist/tree/state/primitive-entity/validation/validation-schema.d.ts

@@ -0,0 +1,251 @@
+import { EntityType } from '../../../../../../../../../../src/definitions';
+import { z } from 'zod';
+
+export declare function getPrimitiveEntityTypeSchema(): z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<EntityType.PrimitiveEntity>;
+}, "strip", z.ZodTypeAny, {
+    type: EntityType.PrimitiveEntity;
+}, {
+    type: EntityType.PrimitiveEntity;
+}>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+export declare function getPrimitiveEntityReferenceSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.GenericReference>;
+    entityId: z.ZodString;
+    entityType: z.ZodLiteral<EntityType.PrimitiveEntity>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: EntityType.GenericReference;
+    entityType: EntityType.PrimitiveEntity;
+    entityId: string;
+}, {
+    id: string;
+    type: EntityType.GenericReference;
+    entityType: EntityType.PrimitiveEntity;
+    entityId: string;
+}>;
+export declare function getPrimitiveEntityBaseSchema(): z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.PrimitiveEntity>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    static: z.ZodBoolean;
+    abstract: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: EntityType.PrimitiveEntity;
+    name: string;
+    description: string | null;
+    static: boolean;
+    abstract: boolean;
+}, {
+    id: string;
+    type: EntityType.PrimitiveEntity;
+    name: string;
+    description: string | null;
+    static: boolean;
+    abstract: boolean;
+}>;
+export declare function getPrimitiveEntityMetaSchema(): z.ZodObject<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.PrimitiveEntity>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    static: z.ZodBoolean;
+    abstract: z.ZodBoolean;
+}, {
+    version: z.ZodNumber;
+}>, "strip", z.ZodTypeAny, {
+    id: string;
+    type: EntityType.PrimitiveEntity;
+    name: string;
+    description: string | null;
+    version: number;
+    static: boolean;
+    abstract: boolean;
+}, {
+    id: string;
+    type: EntityType.PrimitiveEntity;
+    name: string;
+    description: string | null;
+    version: number;
+    static: boolean;
+    abstract: boolean;
+}>;
+export declare function getPrimitiveEntityGenericGenerationTargetSchema(): z.ZodObject<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.PrimitiveEntity>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    static: z.ZodBoolean;
+    abstract: z.ZodBoolean;
+}, {}>, "strip", z.ZodTypeAny, {
+    id: string;
+    type: EntityType.PrimitiveEntity;
+    name: string;
+    description: string | null;
+    static: boolean;
+    abstract: boolean;
+}, {
+    id: string;
+    type: EntityType.PrimitiveEntity;
+    name: string;
+    description: string | null;
+    static: boolean;
+    abstract: boolean;
+}>;
+export declare function getPrimitiveEntityNestedEntitiesSchema(): z.ZodObject<{
+    properties: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.Property>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.Property;
+    }, {
+        type: EntityType.Property;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    methods: 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">;
+    abstractMethods: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.ActionDescriptor>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.ActionDescriptor;
+    }, {
+        type: EntityType.ActionDescriptor;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    extends: z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.PrimitiveEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.PrimitiveEntity;
+    }, {
+        type: EntityType.PrimitiveEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.BuiltInBaseEntity;
+    }, {
+        type: EntityType.BuiltInBaseEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    extends: (Record<string, any> | {
+        type: EntityType.PrimitiveEntity;
+    } | {
+        type: EntityType.BuiltInBaseEntity;
+    })[];
+    methods: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    properties: (Record<string, any> | {
+        type: EntityType.Property;
+    })[];
+    abstractMethods: (Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    })[];
+}, {
+    extends: (Record<string, any> | {
+        type: EntityType.PrimitiveEntity;
+    } | {
+        type: EntityType.BuiltInBaseEntity;
+    })[];
+    methods: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    properties: (Record<string, any> | {
+        type: EntityType.Property;
+    })[];
+    abstractMethods: (Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    })[];
+}>;
+export declare function getPrimitiveEntitySchema(): z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    type: z.ZodLiteral<EntityType.PrimitiveEntity>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    static: z.ZodBoolean;
+    abstract: z.ZodBoolean;
+}, {
+    version: z.ZodNumber;
+}>, {
+    properties: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.Property>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.Property;
+    }, {
+        type: EntityType.Property;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    methods: 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">;
+    abstractMethods: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.ActionDescriptor>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.ActionDescriptor;
+    }, {
+        type: EntityType.ActionDescriptor;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
+    extends: z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.PrimitiveEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.PrimitiveEntity;
+    }, {
+        type: EntityType.PrimitiveEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<EntityType.BuiltInBaseEntity>;
+    }, "strip", z.ZodTypeAny, {
+        type: EntityType.BuiltInBaseEntity;
+    }, {
+        type: EntityType.BuiltInBaseEntity;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>]>, "many">;
+}>, "strip", z.ZodTypeAny, {
+    id: string;
+    type: EntityType.PrimitiveEntity;
+    name: string;
+    description: string | null;
+    extends: (Record<string, any> | {
+        type: EntityType.PrimitiveEntity;
+    } | {
+        type: EntityType.BuiltInBaseEntity;
+    })[];
+    version: number;
+    methods: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    properties: (Record<string, any> | {
+        type: EntityType.Property;
+    })[];
+    abstractMethods: (Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    })[];
+    static: boolean;
+    abstract: boolean;
+}, {
+    id: string;
+    type: EntityType.PrimitiveEntity;
+    name: string;
+    description: string | null;
+    extends: (Record<string, any> | {
+        type: EntityType.PrimitiveEntity;
+    } | {
+        type: EntityType.BuiltInBaseEntity;
+    })[];
+    version: number;
+    methods: (Record<string, any> | {
+        type: EntityType.FunctionDeclaration;
+    })[];
+    properties: (Record<string, any> | {
+        type: EntityType.Property;
+    })[];
+    abstractMethods: (Record<string, any> | {
+        type: EntityType.ActionDescriptor;
+    })[];
+    static: boolean;
+    abstract: boolean;
+}>;

package/dist/tree/state/primitive-value/index.d.ts

@@ -0,0 +1 @@
+export * from './primitive-value';

package/dist/tree/state/primitive-value/primitive-value.d.ts

@@ -0,0 +1,91 @@
+import { IPrimitiveValue, IPrimitiveValueTransfer, EntityId, EntityType, EntityVersion, PrimitiveTypes, IPrimitiveValueReference, ValueAutogenerationOptions, PrimitiveValueType, IPrimitiveValueShallowTransfer, ElementShallowTransfer, IPrimitiveValueGenerationTarget, ElementGenerationTarget, PrimitiveValueTypesUnion } from '../../../../../../../../../src/definitions';
+import { ProjectState } from '../project';
+import { CustomEntityState } from '../custom-entity';
+import { DataTypeState } from '../data-type';
+import { InputMapState } from '../input-map';
+import { ZodError } from 'zod';
+import { BaseState, ChildEntityState, UserManagedEntityStateFunctionality } from '../base';
+import { FunctionDeclarationState } from '../function-declaration';
+import { EntityError, EntityGenerationError } from '../../state/error';
+import { OperationState } from '../operation';
+import { EntityState } from '../types';
+
+export type ValueAsTypeState = CustomEntityState | FunctionDeclarationState | OperationState;
+export declare class PrimitiveValueState implements BaseState, UserManagedEntityStateFunctionality, ChildEntityState, IPrimitiveValue {
+    initialData: IPrimitiveValue | IPrimitiveValueTransfer;
+    readonly type: EntityType.PrimitiveValue;
+    id: EntityId;
+    version: EntityVersion;
+    name: PrimitiveTypes;
+    autogeneration: ValueAutogenerationOptions | null;
+    value: PrimitiveValueType;
+    valueAsType: ValueAsTypeState | ValueAsTypeState[] | null;
+    errors: EntityError[];
+    parent: DataTypeState | InputMapState;
+    project: ProjectState;
+    initialized: boolean;
+    constructor(initialEntityData: IPrimitiveValue | IPrimitiveValueTransfer, 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: IPrimitiveValueGenerationTarget, parentProjectState: ProjectState): PrimitiveValueState;
+    static validateGenerationTarget(data: IPrimitiveValueGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        modifiedData: IPrimitiveValueGenerationTarget;
+    };
+    validateGeneratedUpdate(data: Partial<IPrimitiveValueGenerationTarget>): {
+        errors: EntityGenerationError[];
+        modifiedData: Partial<IPrimitiveValueGenerationTarget>;
+    };
+    addSelfToProject(): PrimitiveValueState;
+    setParent(parent: DataTypeState | InputMapState): PrimitiveValueState;
+    initChildren(): PrimitiveValueState;
+    subscribe(): PrimitiveValueState;
+    unsubscribe(): PrimitiveValueState;
+    sync(data: Partial<IPrimitiveValue>): PrimitiveValueState;
+    load(): Promise<PrimitiveValueState>;
+    create(): Promise<PrimitiveValueState>;
+    update(_: Partial<PrimitiveValueTypesUnion>): Promise<PrimitiveValueState>;
+    delete(): Promise<PrimitiveValueState>;
+    remove({ ignoreUpstream: _, seenEntities, }?: {
+        ignoreUpstream: boolean;
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        removed: EntityState[];
+    };
+    restore({ seenEntities }?: {
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        self: PrimitiveValueState;
+    };
+    toFlat(seenEntities?: Set<string>): EntityState[];
+    toFlatIds(seenEntities?: Set<string>): EntityId[];
+    toJSON(): IPrimitiveValueTransfer;
+    toReference(): IPrimitiveValueReference;
+    toShallowJSON(): IPrimitiveValueShallowTransfer;
+    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toGenerationTarget(): IPrimitiveValueGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    clearErrors(): PrimitiveValueState;
+    validate(): {
+        success: boolean;
+        error: ZodError | null;
+        data: IPrimitiveValueTransfer | null;
+    };
+    getErrors(): EntityError[];
+    getShallowErrors(): EntityError[];
+    clone(parent?: DataTypeState | InputMapState | null, newId?: string | null, subscribe?: boolean): PrimitiveValueState;
+}
+export type PrimitiveValuePayloadUnion = PrimitiveValueState | PrimitiveValueTypesUnion;

package/dist/tree/state/primitive-value/validation/logic-validation.d.ts

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

package/dist/tree/state/primitive-value/validation/references.d.ts

@@ -0,0 +1,5 @@
+import { IPrimitiveValueGenerationTarget } from '../../../../../../../../../../src/definitions';
+import { EntityGenerationError } from '../../error';
+import { ProjectState } from '../../project';
+
+export declare function validateReferenceTypes(data: IPrimitiveValueGenerationTarget, project: ProjectState): EntityGenerationError[];