@elyx-code/project-logic-tree 0.0.1

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

@@ -0,0 +1,28 @@
+export { createStateFromTypeAndSubscribe } from './create';
+export { ProjectState } from './project';
+export { OutputMapState } from './output-map';
+export { PrimitiveEntityState } from './primitive-entity';
+export { CustomEntityState } from './custom-entity';
+export { DataTypeState } from './data-type';
+export { PropertyState } from './property';
+export { VariableDeclarationState } from './variable-declaration';
+export { VariableInstanceState } from './variable-instance';
+export { ArgumentDeclarationState } from './argument-declaration';
+export { ReturnDeclarationState } from './return-declaration';
+export { ActionDescriptorState } from './action-descriptor';
+export { FunctionDeclarationState } from './function-declaration';
+export { OperationState } from './operation';
+export { FunctionCallState } from './function-call';
+export { ConditionState } from './condition';
+export { ReturnStatementState } from './return-statement';
+export { ContinueStatementState } from './continue-statement';
+export { BreakStatementState } from './break-statement';
+export { GlobalEventState } from './global-event';
+export { InputMapState } from './input-map';
+export { InstalledProjectState } from './installed-project';
+export { InternalCallState } from './internal-call';
+export { SearchState } from './search';
+export { LoopState } from './loop';
+export { ValueDescriptorState } from './value-descriptor';
+export { BuiltInBaseEntityState } from './built-in-base-entity';
+export * from './types/state';

package/dist/tree/state/input-map/index.d.ts

@@ -0,0 +1 @@
+export * from './input-map';

package/dist/tree/state/input-map/input-map.d.ts

@@ -0,0 +1,124 @@
+import { EntityId, EntityType, EntityVersion, IInputMap, IInputMapTransfer, IActionInputMap, IActionInputMapTransfer, IInputMapReference, IVariableInputMap, IVariableInputMapTransfer, IInputMapShallowTransfer, ElementShallowTransfer, IInputMapGenerationTarget, ElementGenerationTarget, InputMapTypesUnion } from '../../../../../../../../../src/definitions';
+import { ZodError } from 'zod';
+import { BaseState, ChildEntityState, EntityWithValueClass, UserManagedEntityStateFunctionality, ValueReadingEntityClass } from '../base';
+import { ArgumentDeclarationState } from '../argument-declaration';
+import { EntityState, PassThroughCallableEntityState, ValueWritingEntityState } from '../types';
+import { ProjectState } from '../project/project';
+import { VariableDeclarationState } from '../variable-declaration';
+import { PropertyState } from '../property';
+import { VariableInstanceState } from '../variable-instance';
+import { PrimitiveValueState } from '../primitive-value/primitive-value';
+import { InternalCallState } from '../internal-call';
+import { OperationState } from '../operation';
+import { FunctionCallState } from '../function-call';
+import { ConditionState } from '../condition';
+import { LoopState } from '../loop';
+import { SearchState } from '../search';
+import { EntityError, EntityGenerationError } from '../error';
+import { DataTypeState } from '../data-type';
+import { ValueDescriptorState } from '../value-descriptor';
+
+export declare class InputMapState implements IInputMap, ValueReadingEntityClass, UserManagedEntityStateFunctionality, BaseState, ChildEntityState, EntityWithValueClass {
+    initialData: IInputMap | IInputMapTransfer;
+    readonly id: EntityId;
+    version: EntityVersion;
+    index: number;
+    name: string | null;
+    description: string | null;
+    declaration: ArgumentDeclarationState | PropertyState | ValueDescriptorState | null;
+    readonly type: EntityType.InputMap;
+    defaultValue: PrimitiveValueState | null;
+    readsValue: ValueWritingEntityState | null;
+    dynamicArguments: InputMapState[];
+    project: ProjectState;
+    errors: EntityError[];
+    parent: PassThroughCallableEntityState | InputMapState;
+    initialized: boolean;
+    suggestion: boolean;
+    constructor(initialVariableInputMapData: IInputMap | IInputMapTransfer, 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: IInputMapGenerationTarget, parentProjectState: ProjectState): InputMapState;
+    static validateGenerationTarget(data: IInputMapGenerationTarget, project: ProjectState): {
+        errors: EntityGenerationError[];
+        modifiedData: IInputMapGenerationTarget;
+    };
+    validateGeneratedUpdate(data: Partial<IInputMapGenerationTarget>): {
+        errors: EntityGenerationError[];
+        modifiedData: Partial<IInputMapGenerationTarget>;
+    };
+    addSelfToProject(): InputMapState;
+    setParent(parent: PassThroughCallableEntityState | InputMapState): InputMapState;
+    removeInput(input: InputMapState): InputMapState;
+    addInput(input: InputMapState): InputMapState;
+    initChildren(): InputMapState;
+    setValueWriter(valueWriter: ValueWritingEntityState): InputMapState;
+    subscribe(): InputMapState;
+    unsubscribe(): InputMapState;
+    sync(data: Partial<IInputMap>): InputMapState;
+    load(): Promise<InputMapState>;
+    create(): Promise<InputMapState>;
+    update(data: Partial<InputMapTypesUnion>): Promise<InputMapState>;
+    delete(): Promise<InputMapState>;
+    remove({ ignoreUpstream, seenEntities, }?: {
+        ignoreUpstream: boolean;
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        removed: EntityState[];
+    };
+    restore({ seenEntities }?: {
+        seenEntities: Set<string>;
+    }): {
+        affected: EntityState[];
+        self: InputMapState;
+    };
+    toFlat(seenEntities?: Set<string>): EntityState[];
+    toFlatIds(seenEntities?: Set<string>): EntityId[];
+    toJSON(): IInputMapTransfer;
+    toReference(): IInputMapReference;
+    toShallowJSON(): IInputMapShallowTransfer;
+    toFlatJSON(seenEntities?: Set<string>): ElementShallowTransfer[];
+    toGenerationTarget(): IInputMapGenerationTarget;
+    toFlatGenerationTarget(seenEntities?: Set<string>): ElementGenerationTarget[];
+    clearErrors(): InputMapState;
+    validate(): {
+        success: boolean;
+        error: ZodError | null;
+        data: IInputMapTransfer | null;
+    };
+    getErrors(): EntityError[];
+    getShallowErrors(): EntityError[];
+    getDefaultValue(): PrimitiveValueState | null;
+    setDefaultValue(value: PrimitiveValueState): InputMapState;
+    clone(_?: PassThroughCallableEntityState): InputMapState;
+    getDataType(): DataTypeState | null;
+}
+export declare class VariableInputMapState extends InputMapState implements IVariableInputMap {
+    declaration: PropertyState | null;
+    parent: VariableInstanceState | VariableDeclarationState;
+    errors: EntityError[];
+    constructor(initialVariableInputMapData: IVariableInputMap | IVariableInputMapTransfer, parentProjectState: ProjectState);
+    toJSON(): IVariableInputMapTransfer;
+}
+export declare class ActionInputMapState extends InputMapState implements IActionInputMap {
+    name: null;
+    description: null;
+    declaration: ArgumentDeclarationState | ValueDescriptorState;
+    parent: OperationState | FunctionCallState | ConditionState | LoopState | SearchState | InternalCallState | InputMapState;
+    errors: EntityError[];
+    constructor(initialActionInputMapData: IActionInputMap | IActionInputMapTransfer, parentProjectState: ProjectState);
+    toJSON(): IActionInputMapTransfer;
+}
+export type InputMapPayloadUnion = InputMapState | InputMapTypesUnion;

package/dist/tree/state/input-map/validation/logic-validation.d.ts

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