@amodx/ncs 0.0.1

package/Components/ComponentData.d.ts

@@ -0,0 +1,112 @@
+import { Property } from "@amodx/schemas";
+import { ComponentInstance } from "./ComponentInstance";
+import { TraitData } from "../Traits/TraitData";
+/**
+ * Interface representing the meta data of a component.
+ */
+export interface ComponentMetaData {
+    name: string;
+    [key: string]: any;
+}
+/**
+ * Interface representing the pool data of a component.
+ */
+export interface ComponentPoolData {
+    maxSize: number;
+    [key: string]: any;
+}
+/**
+ * Interface representing the state data of a component.
+ */
+export interface ComponentStateData {
+    [key: string]: any;
+}
+/**
+ * Type representing the data of a component.
+ *
+ * @template ComponentSchema - The ComponentSchema of the component.
+ */
+export type ComponentData<ComponentSchema extends object = any> = {
+    /**
+     * The type of the component.
+     */
+    type: string;
+    /**
+     * The namespace of the component.
+     */
+    namespace?: string;
+    /**
+     * The state data of the component.
+     */
+    state: ComponentStateData;
+    /**
+     * The ComponentSchema of the component.
+     */
+    schema: ComponentSchema;
+    /**
+     * The traits associated with the component.
+     */
+    traits: TraitData[];
+};
+/**
+ * Type representing the data required to register a component.
+ *
+ * Used for serlization and creation.
+ * @template ComponentSchema - The schema of the component.
+ * @template Data - The runtime data of the component.
+ * @template Logic - The logic functions of the component.
+ * @template Shared - The shared data of all components of this type.
+ * @template Meta - The shared meta data of all components of this type.
+ */
+export type ComponentRegisterData<ComponentSchema extends object = {}, Data extends Record<string, any> = {}, Logic extends Record<string, any> = {}, Shared extends Record<string, any> = {}> = {
+    /**
+     * The type of the component.
+     */
+    type: string;
+    /**
+     * The namespace of the component.
+     */
+    namespace?: string;
+    pool?: ComponentPoolData;
+    /**
+     * The schema used to create an editable version of the component.
+     * For the actual ComponentInstance the schema is created into an object.
+     */
+    schema?: Property<any, any>[];
+    /**
+     * The logic functions of the component.
+     */
+    logic?: Logic | ((component: ComponentInstance<ComponentSchema, Data, Logic, Shared>) => Logic);
+    /**
+     * The runtime data of the component.
+     */
+    data?: Data | ((component: ComponentInstance<ComponentSchema, Data, Logic, Shared>) => Data);
+    /**
+     * The shared data of all components.
+     */
+    shared?: Shared;
+    /**
+     * The shared meta data of all components.
+     */
+    meta?: ComponentMetaData;
+    /**
+     * Optional initialization function for the component.
+     *
+     * @param component - The instance of the component being initialized.
+     */
+    init?(component: ComponentInstance<ComponentSchema, Data, Logic, Shared>): Promise<void> | void;
+    /**
+     * Optional update function for the component.
+     * The update function is usually called once per frame.
+     * It is up to the graph though when it gets called.
+     *
+     * @param component - The instance of the component being updated.
+     */
+    update?(component: ComponentInstance<ComponentSchema, Data, Logic, Shared>): Promise<void> | void;
+    /**
+     * Optional disposal function for the component.
+     *
+     * @param component - The instance of the component being disposed.
+     */
+    dispose?(component: ComponentInstance<ComponentSchema, Data, Logic, Shared>): Promise<void> | void;
+};

package/Components/ComponentData.js

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

package/Components/ComponentInstance.d.ts

@@ -0,0 +1,36 @@
+import { ComponentData, ComponentStateData } from "./ComponentData";
+import { ObjectSchemaInstance, QueryPath } from "@amodx/schemas";
+import { SchemaNode } from "@amodx/schemas/Schemas/SchemaNode";
+import { NodeInstance } from "../Nodes/NodeInstance";
+import { ComponentObservers } from "./ComponentObservers";
+import { ComponentPipelines } from "./ComponentPipelines";
+import { TraintContainer } from "../Traits/TraitContainer";
+import { ComponentPrototype } from "./ComponentPrototype";
+export declare class ComponentInstance<ComponentSchema extends object = {}, Data extends object = {}, Logic extends object = {}, Shared extends object = {}> {
+    get type(): string;
+    get shared(): Shared;
+    componentPrototype: ComponentPrototype<ComponentSchema, Data, Logic, Shared>;
+    schema: ObjectSchemaInstance<ComponentSchema>;
+    data: Data;
+    logic: Logic;
+    state: ComponentStateData;
+    private _traits?;
+    get traits(): TraintContainer;
+    get hasTraits(): boolean;
+    private _observers?;
+    get observers(): ComponentObservers;
+    get hasObservers(): boolean;
+    private _pipelines?;
+    get pipelines(): ComponentPipelines<ComponentSchema>;
+    get hasPipelines(): boolean;
+    node: NodeInstance;
+    addOnSchemaUpdate(path: QueryPath<ComponentSchema>, listener: (node: SchemaNode) => void): void;
+    removeOnSchemaUpdate(path: QueryPath<ComponentSchema>, listener: (node: SchemaNode) => void): void;
+    init(): Promise<void>;
+    private _disposed;
+    isDisposed(): boolean;
+    dispose(): Promise<void>;
+    getDependencies(): boolean;
+    copy(): ComponentData;
+    toJSON(): ComponentData;
+}

package/Components/ComponentInstance.js

@@ -0,0 +1,125 @@
+import { ObjectPath } from "@amodx/schemas";
+import { GraphUpdate } from "../Graphs/GraphUpdate";
+import { ComponentObservers } from "./ComponentObservers";
+import { ComponentPipelines } from "./ComponentPipelines";
+import { TraintContainer } from "../Traits/TraitContainer";
+export class ComponentInstance {
+    get type() {
+        return this.componentPrototype.data.type;
+    }
+    get shared() {
+        return this.componentPrototype.data.shared;
+    }
+    componentPrototype;
+    schema;
+    data;
+    logic;
+    state;
+    _traits;
+    get traits() {
+        if (!this._traits) {
+            this._traits = new TraintContainer(this);
+        }
+        return this._traits;
+    }
+    get hasTraits() {
+        return Boolean(this._traits);
+    }
+    _observers;
+    get observers() {
+        if (!this._observers) {
+            this._observers = new ComponentObservers();
+        }
+        return this._observers;
+    }
+    get hasObservers() {
+        return Boolean(this._observers);
+    }
+    _pipelines;
+    get pipelines() {
+        if (!this._pipelines) {
+            this._pipelines = new ComponentPipelines();
+        }
+        return this._pipelines;
+    }
+    get hasPipelines() {
+        return Boolean(this._pipelines);
+    }
+    node;
+    addOnSchemaUpdate(path, listener) {
+        this.schema
+            .getSchema()
+            .getNode(ObjectPath.Create(path))
+            ?.observers.updatedOrLoadedIn.subscribe(listener);
+    }
+    removeOnSchemaUpdate(path, listener) {
+        this.schema
+            .getSchema()
+            .getNode(ObjectPath.Create(path))
+            ?.observers.updatedOrLoadedIn.unsubscribe(listener);
+    }
+    async init() {
+        if (!this.componentPrototype.data.init)
+            return;
+        await this.componentPrototype.data.init(this);
+        if (this.componentPrototype.data.update) {
+            GraphUpdate.addComponentToUpdate(this);
+        }
+    }
+    _disposed = false;
+    isDisposed() {
+        return this._disposed;
+    }
+    async dispose() {
+        if (this.componentPrototype.data.update) {
+            GraphUpdate.removeComponentFromUpate(this);
+        }
+        this.hasPipelines &&
+            this.pipelines.isDisposedSet() &&
+            this.pipelines.disposed.pipe(this);
+        this.hasObservers &&
+            this.observers.isDisposedSet() &&
+            this.observers.disposed.notify();
+        if (this.componentPrototype.data.dispose)
+            await this.componentPrototype.data.dispose(this);
+        this._disposed = true;
+        if (this.hasTraits)
+            await this.traits.dispose();
+        this.componentPrototype.destory(this);
+        delete this._traits;
+        delete this._observers;
+        delete this._pipelines;
+    }
+    getDependencies() {
+        //  return this.node.graph.dependencies;
+        return false;
+    }
+    copy() {
+        const data = {
+            schema: this.schema?.getSchema
+                ? this.schema.getSchema().store()
+                : {},
+            type: this.type,
+            state: this.state,
+            traits: (this.hasTraits && this.traits.traits.map((_) => _.toJSON())) || [],
+        };
+        return ((this.hasPipelines &&
+            this.pipelines.isCopySet() &&
+            this.pipelines.copy.pipe(data)) ||
+            data);
+    }
+    toJSON() {
+        const data = {
+            schema: this.schema?.getSchema
+                ? this.schema.getSchema().store()
+                : {},
+            type: this.type,
+            state: this.state,
+            traits: (this.hasTraits && this.traits.traits.map((_) => _.toJSON())) || [],
+        };
+        return ((this.hasPipelines &&
+            this.pipelines.isToJSONSet() &&
+            this.pipelines.toJSON.pipe(data)) ||
+            data);
+    }
+}

package/Components/ComponentInstanceMap.d.ts

@@ -0,0 +1,7 @@
+import { ComponentInstance } from "./ComponentInstance";
+import { ItemGraphMap } from "../Maps/ItemGraphMap";
+export declare class ComponentInstanceMap {
+    private static types;
+    static registerComponent(type: string): ItemGraphMap<any>;
+    static getMap(type: string): ItemGraphMap<ComponentInstance<any, any, any, any>>;
+}

package/Components/ComponentInstanceMap.js

@@ -0,0 +1,15 @@
+import { ItemGraphMap } from "../Maps/ItemGraphMap";
+export class ComponentInstanceMap {
+    static types = new Map();
+    static registerComponent(type) {
+        const map = new ItemGraphMap();
+        this.types.set(type, map);
+        return map;
+    }
+    static getMap(type) {
+        const map = this.types.get(type);
+        if (!map)
+            throw new Error(`Map for component ${type} does not exist`);
+        return map;
+    }
+}

package/Components/ComponentObservers.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "@amodx/core/Observers";
+export interface ComponentObservers {
+}
+export declare class ComponentObservers {
+    private _disposed?;
+    get disposed(): Observable<void>;
+    isDisposedSet(): boolean;
+}

package/Components/ComponentObservers.js

@@ -0,0 +1,13 @@
+import { Observable } from "@amodx/core/Observers";
+export class ComponentObservers {
+    _disposed;
+    get disposed() {
+        if (!this._disposed) {
+            this._disposed = new Observable();
+        }
+        return this._disposed;
+    }
+    isDisposedSet() {
+        return !!this._disposed;
+    }
+}

package/Components/ComponentPipelines.d.ts

@@ -0,0 +1,16 @@
+import { Pipeline } from "@amodx/core/Pipelines";
+import { ComponentInstance } from "./ComponentInstance";
+import { ComponentData } from "./ComponentData";
+export interface ComponentPipelines {
+}
+export declare class ComponentPipelines<ComponentSchema extends object = {}> {
+    private _disposed?;
+    private _toJSON?;
+    private _copy?;
+    get disposed(): Pipeline<ComponentInstance<ComponentSchema>>;
+    get toJSON(): Pipeline<ComponentData<ComponentSchema>>;
+    get copy(): Pipeline<ComponentData<ComponentSchema>>;
+    isDisposedSet(): boolean;
+    isToJSONSet(): boolean;
+    isCopySet(): boolean;
+}

package/Components/ComponentPipelines.js

@@ -0,0 +1,33 @@
+import { Pipeline } from "@amodx/core/Pipelines";
+export class ComponentPipelines {
+    _disposed;
+    _toJSON;
+    _copy;
+    get disposed() {
+        if (!this._disposed) {
+            this._disposed = new Pipeline();
+        }
+        return this._disposed;
+    }
+    get toJSON() {
+        if (!this._toJSON) {
+            this._toJSON = new Pipeline();
+        }
+        return this._toJSON;
+    }
+    get copy() {
+        if (!this._copy) {
+            this._copy = new Pipeline();
+        }
+        return this._copy;
+    }
+    isDisposedSet() {
+        return !!this._disposed;
+    }
+    isToJSONSet() {
+        return !!this._toJSON;
+    }
+    isCopySet() {
+        return !!this._copy;
+    }
+}

package/Components/ComponentPrototype.d.ts

@@ -0,0 +1,17 @@
+import { ObjectSchemaInstance, Schema } from "@amodx/schemas";
+import { ComponentData, ComponentRegisterData } from "./ComponentData";
+import { ComponentInstance } from "./ComponentInstance";
+import { NodeInstance } from "../Nodes/NodeInstance";
+import { ItemPool } from "../Pools/ItemPool";
+export declare class ComponentPrototype<ComponentSchema extends object = {}, Data extends Record<string, any> = {}, Logic extends Record<string, any> = {}, Shared extends Record<string, any> = {}> {
+    data: ComponentRegisterData<ComponentSchema, Data, Logic, Shared>;
+    schemaController: Schema<ComponentSchema> | null;
+    baseContextSchema: ComponentSchema;
+    pool: ItemPool<ComponentInstance<ComponentSchema, Data, Logic, Shared>>;
+    constructor(data: ComponentRegisterData<ComponentSchema, Data, Logic, Shared>);
+    getSchema(overrides: Partial<ComponentSchema>): ObjectSchemaInstance<ComponentSchema>;
+    private getPooled;
+    private return;
+    create(node: NodeInstance, data: ComponentData): ComponentInstance<ComponentSchema, Data, Logic, Shared>;
+    destory(component: ComponentInstance<ComponentSchema, Data, Logic, Shared>): void;
+}

package/Components/ComponentPrototype.js

@@ -0,0 +1,73 @@
+import { Schema } from "@amodx/schemas";
+import { ComponentInstance } from "./ComponentInstance";
+import { ComponentInstanceMap } from "./ComponentInstanceMap";
+import { ItemPool } from "../Pools/ItemPool";
+export class ComponentPrototype {
+    data;
+    schemaController;
+    baseContextSchema;
+    pool = new ItemPool();
+    constructor(data) {
+        this.data = data;
+        this.schemaController =
+            Array.isArray(data.schema) && data.schema.length
+                ? Schema.Create(...data.schema)
+                : null;
+        this.baseContextSchema = (this.schemaController ? this.schemaController.createData() : {});
+        this.pool.maxSize = data.pool?.maxSize || 100;
+    }
+    getSchema(overrides) {
+        if (!this.schemaController)
+            return structuredClone(this.baseContextSchema);
+        return this.schemaController.instantiate(overrides);
+    }
+    getPooled() {
+        let comp = null;
+        if (this.data.pool?.maxSize) {
+            comp = this.pool.get();
+        }
+        return comp || new ComponentInstance();
+    }
+    return(component) {
+        if (this.data.pool?.maxSize) {
+            return this.pool.addItem(component);
+        }
+        return null;
+    }
+    create(node, data) {
+        const instance = this.getPooled();
+        instance.node = node;
+        instance.componentPrototype = this;
+        if (this.data.schema && !instance.schema) {
+            instance.schema = this.getSchema(data.schema);
+        }
+        if (this.data.schema && instance.schema?.getSchema) {
+            instance.schema.getSchema().loadIn(this.data.schema);
+        }
+        if (this.data.logic) {
+            instance.logic = this.data.logic
+                ? typeof this.data.logic == "function"
+                    ? this.data.logic(instance)
+                    : structuredClone(this.data.logic)
+                : {};
+        }
+        if (this.data.data) {
+            instance.data = this.data.data
+                ? typeof this.data.data == "function"
+                    ? this.data.data(instance)
+                    : structuredClone(this.data.data)
+                : {};
+        }
+        if (data.state) {
+            instance.state = structuredClone(data.state);
+        }
+        const map = ComponentInstanceMap.getMap(data.type);
+        map.addNode(node, instance);
+        return instance;
+    }
+    destory(component) {
+        const map = ComponentInstanceMap.getMap(component.type);
+        map.removeNode(component.node, component);
+        this.return(component);
+    }
+}

package/Contexts/ContextData.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Interface representing the meta data of a context.
+ */
+export interface ContextMetaData {
+    name: string;
+    [key: string]: any;
+}
+/**
+ * Interface representing the state data of a context.
+ */
+export interface ContextStateData {
+    [key: string]: any;
+}
+/**
+ * Type representing the data of a context.
+ *
+ */
+export type ContextData<Schema extends Record<string, any> = {}> = {
+    /**
+     * The type of the context.
+     */
+    type: string;
+    /**
+     * The namespace of the context.
+     */
+    namespace?: string;
+    /**
+     * The schema of the context.
+     */
+    schema: Schema;
+};
+/**
+ * Type representing the data required to register a context.
+ *
+ * Used for serlization and creation.
+ * @template Data - The runtime data of the context.
+ */
+export type ContextRegisterData<Schema extends Record<string, any> = {}, Data extends Record<string, any> = {}> = {
+    /**
+     * The type of the context.
+     */
+    type: string;
+    /**
+     * The namespace of the context.
+     */
+    namespace?: string;
+    /**
+     * The schema of the context.
+     */
+    schema?: Schema;
+    /**
+     * The runtime data of the context.
+     */
+    data?: Data;
+    /**
+     * The shared meta data of all contexts.
+     */
+    meta?: ContextMetaData;
+};

package/Contexts/ContextData.js

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

package/Contexts/ContextInstance.d.ts

@@ -0,0 +1,14 @@
+import { ContextData } from "./ContextData";
+import { NodeInstance } from "../Nodes/NodeInstance";
+import { ObjectSchemaInstance, QueryPath } from "@amodx/schemas";
+import { SchemaNode } from "@amodx/schemas/Schemas/SchemaNode";
+import { ContextPrototype } from "./ContextPrototype";
+export declare class ContextInstance<ContextSchema extends {} = {}, Data extends {} = {}> {
+    node: NodeInstance;
+    type: string;
+    data: Data;
+    schema: ObjectSchemaInstance<ContextSchema>;
+    constructor(node: NodeInstance, contextPrototypeData: ContextPrototype<ContextSchema, Data>, data: ContextData);
+    addOnSchemaUpdate(path: QueryPath<ContextSchema>, listener: (node: SchemaNode) => void): void;
+    removeOnSchemaUpdate(path: QueryPath<ContextSchema>, listener: (node: SchemaNode) => void): void;
+}

package/Contexts/ContextInstance.js

@@ -0,0 +1,26 @@
+import { ObjectPath } from "@amodx/schemas";
+export class ContextInstance {
+    node;
+    type;
+    data;
+    schema;
+    constructor(node, contextPrototypeData, data) {
+        this.node = node;
+        this.schema = contextPrototypeData.getSchema(data.schema);
+        this.type = contextPrototypeData.data.type;
+        contextPrototypeData.data.data &&
+            (this.data = contextPrototypeData.data.data);
+    }
+    addOnSchemaUpdate(path, listener) {
+        this.schema
+            .getSchema()
+            .getNode(ObjectPath.Create(path))
+            ?.observers.updatedOrLoadedIn.subscribe(listener);
+    }
+    removeOnSchemaUpdate(path, listener) {
+        this.schema
+            .getSchema()
+            .getNode(ObjectPath.Create(path))
+            ?.observers.updatedOrLoadedIn.unsubscribe(listener);
+    }
+}

package/Contexts/ContextInstanceAnchor.d.ts

@@ -0,0 +1,15 @@
+import { NodeInstance } from "../Nodes/NodeInstance";
+import { ContextInstance } from "./ContextInstance";
+import { QueryPath } from "@amodx/schemas";
+import { SchemaNode } from "@amodx/schemas/Schemas/SchemaNode";
+export declare class ContextAnchorInstance<ContextSchema extends {} = {}, Data extends {} = {}> {
+    node: NodeInstance;
+    private context;
+    get type(): string;
+    get schema(): import("@amodx/schemas").ObjectSchemaInstance<Data>;
+    get data(): {};
+    constructor(node: NodeInstance, context: ContextInstance<Data>);
+    getContext(): ContextInstance<Data, {}>;
+    addOnSchemaUpdate(path: QueryPath<ContextSchema>, listener: (node: SchemaNode) => void): void;
+    removeOnSchemaUpdate(path: QueryPath<ContextSchema>, listener: (node: SchemaNode) => void): void;
+}

package/Contexts/ContextInstanceAnchor.js

@@ -0,0 +1,33 @@
+import { ObjectPath } from "@amodx/schemas";
+export class ContextAnchorInstance {
+    node;
+    context;
+    get type() {
+        return this.context.type;
+    }
+    get schema() {
+        return this.context.schema;
+    }
+    get data() {
+        return this.context.data;
+    }
+    constructor(node, context) {
+        this.node = node;
+        this.context = context;
+    }
+    getContext() {
+        return this.context;
+    }
+    addOnSchemaUpdate(path, listener) {
+        this.schema
+            .getSchema()
+            .getNode(ObjectPath.Create(path))
+            ?.observers.updatedOrLoadedIn.subscribe(listener);
+    }
+    removeOnSchemaUpdate(path, listener) {
+        this.schema
+            .getSchema()
+            .getNode(ObjectPath.Create(path))
+            ?.observers.updatedOrLoadedIn.unsubscribe(listener);
+    }
+}

package/Contexts/ContextPrototype.d.ts

@@ -0,0 +1,9 @@
+import { ObjectSchemaInstance, Schema } from "@amodx/schemas";
+import { ContextRegisterData } from "./ContextData";
+export declare class ContextPrototype<ComponentSchema extends object = {}, Data extends object = {}> {
+    data: ContextRegisterData<ComponentSchema, Data>;
+    schemaController: Schema<ComponentSchema> | null;
+    baseContextSchema: ComponentSchema;
+    constructor(data: ContextRegisterData<ComponentSchema, Data>);
+    getSchema(overrides: Partial<ComponentSchema>): ObjectSchemaInstance<ComponentSchema>;
+}

package/Contexts/ContextPrototype.js

@@ -0,0 +1,19 @@
+import { Schema } from "@amodx/schemas";
+export class ContextPrototype {
+    data;
+    schemaController;
+    baseContextSchema;
+    constructor(data) {
+        this.data = data;
+        this.schemaController =
+            Array.isArray(data.schema) && data.schema.length
+                ? Schema.Create(...data.schema)
+                : null;
+        this.baseContextSchema = (this.schemaController ? this.schemaController.createData() : {});
+    }
+    getSchema(overrides) {
+        if (!this.schemaController)
+            return structuredClone(this.baseContextSchema);
+        return this.schemaController.instantiate(overrides);
+    }
+}

package/Graphs/Graph.d.ts

@@ -0,0 +1,24 @@
+import { NodeData } from "../Nodes/NodeData";
+import { NodeInstance } from "../Nodes/NodeInstance";
+import { NodeId } from "../Nodes/NodeId";
+import { GraphEvents } from "./GraphEvents";
+import { GraphObservers } from "./GraphObservers";
+export interface GraphDependencies {
+    [key: string]: any;
+}
+export interface Graph {
+}
+export declare class Graph {
+    dependencies: GraphDependencies;
+    _nodeMap: Map<BigInt, Map<BigInt, NodeInstance>>;
+    events: GraphEvents;
+    observers: GraphObservers;
+    root: NodeInstance;
+    constructor(dependencies: GraphDependencies);
+    getNode(id: NodeId | string): NodeInstance;
+    loadInRoot(data: NodeData): Promise<void>;
+    addNode(data: NodeData, parent?: NodeInstance): Promise<NodeInstance>;
+    removeNode(id: NodeId): void;
+    update(): void;
+    toJSON(): NodeData;
+}