@amodx/ncs 0.0.1

package/Nodes/NodeData.d.ts

@@ -0,0 +1,40 @@
+import { TagData } from "../Tags/TagData";
+import { ComponentData } from "../Components/ComponentData";
+/**
+ * Interface representing the state data of a node.
+ */
+export interface NodeStateData {
+    [key: string]: any;
+}
+/**
+ * Type representing the data of a node.
+ *
+ * Used for serlization and creation.
+ */
+export type NodeData = {
+    /**
+     * The unique 128 bit identifier of the node.
+     *
+     */
+    id: string;
+    /**
+     * The name of the node.
+     */
+    name: string;
+    /**
+     * The state data of the node.
+     */
+    state: NodeStateData;
+    /**
+     * The components of the node.
+     */
+    components?: ComponentData[];
+    /**
+     * The tags of the node.
+     */
+    tags?: TagData[];
+    /**
+     * The children nodes of the node.
+     */
+    children: NodeData[];
+};

package/Nodes/NodeData.js

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

package/Nodes/NodeEvents.d.ts

@@ -0,0 +1,25 @@
+import { Observable } from "@amodx/core/Observers";
+import { NodeInstance } from "./NodeInstance";
+export declare class NodeEventCursor {
+    id: string;
+    node: NodeInstance;
+    data: any;
+}
+declare class NodeEventsObservers {
+    eventTypeAdded: Observable<string>;
+    eventDispatched: Observable<NodeEventCursor>;
+}
+export declare class NodeEvents {
+    node: NodeInstance;
+    observers: NodeEventsObservers;
+    private cursor;
+    private events;
+    constructor(node: NodeInstance);
+    hasListener(id: string): boolean;
+    clearListeners(id: string): false | undefined;
+    addListener<Data>(id: string, run: (data: Data) => void): void;
+    removeListener(id: string, run: Function): boolean;
+    dispatch<Data>(id: string, data: Data): boolean;
+    dispatchDeep<Data>(id: string, data: Data): void;
+}
+export {};

package/Nodes/NodeEvents.js

@@ -0,0 +1,62 @@
+import { Observable } from "@amodx/core/Observers";
+export class NodeEventCursor {
+    id;
+    node;
+    data;
+}
+class NodeEventsObservers {
+    eventTypeAdded = new Observable();
+    eventDispatched = new Observable();
+}
+export class NodeEvents {
+    node;
+    observers = new NodeEventsObservers();
+    cursor = new NodeEventCursor();
+    events = new Map();
+    constructor(node) {
+        this.node = node;
+    }
+    hasListener(id) {
+        return this.events.has(id);
+    }
+    clearListeners(id) {
+        let observer = this.events.get(id);
+        if (!observer)
+            return false;
+        observer.clear();
+    }
+    addListener(id, run) {
+        let observer = this.events.get(id);
+        if (!observer) {
+            observer = new Observable();
+            this.events.set(id, observer);
+            this.observers.eventTypeAdded.notify(id);
+        }
+        observer.subscribe(run);
+    }
+    removeListener(id, run) {
+        let observer = this.events.get(id);
+        if (!observer)
+            return false;
+        observer.unsubscribe(run);
+        return true;
+    }
+    dispatch(id, data) {
+        let observer = this.events.get(id);
+        if (!observer)
+            return false;
+        observer.notify(data);
+        this.cursor.id = id;
+        this.cursor.data = data;
+        this.observers.eventDispatched.notify(this.cursor);
+        if (this.node.graph.events.hasListener(id)) {
+            this.node.graph.events.dispatch(id, this.cursor);
+        }
+        return true;
+    }
+    dispatchDeep(id, data) {
+        for (const child of this.node.traverseChildren()) {
+            child.events.dispatch(id, data);
+        }
+    }
+}

package/Nodes/NodeId.d.ts

@@ -0,0 +1,15 @@
+export declare class NodeId {
+    high: bigint;
+    low: bigint;
+    private _idString;
+    get idString(): string;
+    set idString(id: string);
+    private constructor();
+    static Compare(id: NodeId, id2: NodeId): boolean;
+    static Create(id?: string): NodeId;
+    static FromString(id: string): {
+        high: bigint;
+        low: bigint;
+    };
+    static ToHexString(id: NodeId): string;
+}

package/Nodes/NodeId.js

@@ -0,0 +1,56 @@
+export class NodeId {
+    high;
+    low;
+    _idString = "";
+    get idString() {
+        if (!this._idString)
+            this._idString = NodeId.ToHexString(this);
+        return this._idString;
+    }
+    set idString(id) {
+        this._idString = id;
+    }
+    constructor(low, high) {
+        this.low = low;
+        this.high = high;
+    }
+    static Compare(id, id2) {
+        return id.low == id2.low && id.high == id2.high;
+    }
+    static Create(id) {
+        if (id) {
+            const { high, low } = NodeId.FromString(id);
+            return new NodeId(low, high);
+        }
+        else {
+            const array = new Uint8Array(16);
+            crypto.getRandomValues(array);
+            const high = (BigInt(array[0]) << 56n) |
+                (BigInt(array[1]) << 48n) |
+                (BigInt(array[2]) << 40n) |
+                (BigInt(array[3]) << 32n) |
+                (BigInt(array[4]) << 24n) |
+                (BigInt(array[5]) << 16n) |
+                (BigInt(array[6]) << 8n) |
+                BigInt(array[7]);
+            const low = (BigInt(array[8]) << 56n) |
+                (BigInt(array[9]) << 48n) |
+                (BigInt(array[10]) << 40n) |
+                (BigInt(array[11]) << 32n) |
+                (BigInt(array[12]) << 24n) |
+                (BigInt(array[13]) << 16n) |
+                (BigInt(array[14]) << 8n) |
+                BigInt(array[15]);
+            return new NodeId(low, high);
+        }
+    }
+    static FromString(id) {
+        const high = BigInt("0x" + id.slice(0, 16));
+        const low = BigInt("0x" + id.slice(16, 32));
+        return { high, low };
+    }
+    static ToHexString(id) {
+        return (id.high.toString(16).padStart(16, "0") +
+            id.low.toString(16).padStart(16, "0"));
+    }
+}

package/Nodes/NodeInstance.d.ts

@@ -0,0 +1,50 @@
+import { Graph } from "../Graphs/Graph";
+import { NodeId } from "./NodeId";
+import { NodeData, NodeStateData } from "./NodeData";
+import { NodeEvents } from "./NodeEvents";
+import { NodeObservers } from "./NodeObservers";
+import { NodePipelines } from "./NodePipelines";
+import { NodeContext } from "./Context/NodeContext";
+import { NodeComponents } from "./Components/NodeComponents";
+import { NodeTags } from "./Tags/NodeTags";
+export interface NodeInstance {
+}
+export declare class NodeInstance {
+    parent: NodeInstance;
+    graph: Graph;
+    get id(): NodeId;
+    name: string;
+    state: NodeStateData;
+    private _events?;
+    get events(): NodeEvents;
+    get hasEvents(): boolean;
+    private _context?;
+    get context(): NodeContext;
+    get hasContexts(): boolean;
+    private _observers?;
+    get observers(): NodeObservers;
+    get hasObservers(): boolean;
+    private _pipelines?;
+    get pipelines(): NodePipelines;
+    get hasPipelines(): boolean;
+    private _components?;
+    get components(): NodeComponents;
+    get hasComponents(): boolean;
+    private _tags?;
+    get tags(): NodeTags;
+    get hasTags(): boolean;
+    children: NodeInstance[];
+    private nodeId;
+    constructor(parent: NodeInstance, data: NodeData, graph: Graph);
+    traverseChildren(): Generator<NodeInstance>;
+    traverseParents(): Generator<NodeInstance>;
+    private _disposed;
+    isDisposed(): boolean;
+    dispose(): Promise<void>;
+    addChildren(...nodes: NodeData[]): Promise<void>;
+    parentTo(node: NodeInstance): void;
+    addChild(node: NodeInstance): void;
+    removeChild(id: NodeId): NodeInstance | null;
+    copy(): NodeData;
+    toJSON(): NodeData;
+}

package/Nodes/NodeInstance.js

@@ -0,0 +1,202 @@
+import { NodeId } from "./NodeId";
+import { NodeEvents } from "./NodeEvents";
+import { NodeObservers } from "./NodeObservers";
+import { NodePipelines } from "./NodePipelines";
+import { NodeContext } from "./Context/NodeContext";
+import { NodeComponents } from "./Components/NodeComponents";
+import { NodeTags } from "./Tags/NodeTags";
+export class NodeInstance {
+    parent;
+    graph;
+    get id() {
+        return this.nodeId;
+    }
+    name;
+    state;
+    _events;
+    get events() {
+        if (!this._events) {
+            this._events = new NodeEvents(this);
+        }
+        return this._events;
+    }
+    get hasEvents() {
+        return Boolean(this._context);
+    }
+    _context;
+    get context() {
+        if (!this._context) {
+            this._context = new NodeContext(this);
+        }
+        return this._context;
+    }
+    get hasContexts() {
+        return Boolean(this._context);
+    }
+    _observers;
+    get observers() {
+        if (!this._observers) {
+            this._observers = new NodeObservers();
+        }
+        return this._observers;
+    }
+    get hasObservers() {
+        return Boolean(this._observers);
+    }
+    _pipelines;
+    get pipelines() {
+        if (!this._pipelines) {
+            this._pipelines = new NodePipelines();
+        }
+        return this._pipelines;
+    }
+    get hasPipelines() {
+        return Boolean(this._pipelines);
+    }
+    _components;
+    get components() {
+        if (!this._components) {
+            this._components = new NodeComponents(this);
+        }
+        return this._components;
+    }
+    get hasComponents() {
+        return Boolean(this._components);
+    }
+    _tags;
+    get tags() {
+        if (!this._tags) {
+            this._tags = new NodeTags(this);
+        }
+        return this._tags;
+    }
+    get hasTags() {
+        return Boolean(this._tags);
+    }
+    children = [];
+    nodeId;
+    constructor(parent, data, graph) {
+        this.parent = parent;
+        this.graph = graph;
+        this.name = data.name;
+        this.state = data.state;
+        this.nodeId = NodeId.Create(data.id);
+    }
+    *traverseChildren() {
+        const children = [...this.children];
+        while (children.length) {
+            const child = children.shift();
+            yield child;
+            if (child.children.length)
+                children.push(...child.children);
+        }
+    }
+    *traverseParents() {
+        let parent = this.parent;
+        while (parent) {
+            yield parent;
+            parent = parent.parent;
+        }
+    }
+    _disposed = false;
+    isDisposed() {
+        return this._disposed;
+    }
+    async dispose() {
+        if (this._disposed)
+            return;
+        this._disposed = true;
+        this.graph.removeNode(this.id);
+        this.parent?.removeChild(this.id);
+        this.hasComponents && (await this.components.dispose());
+        this.hasTags && (await this.tags.dispose());
+        for (const child of this.children) {
+            await child.dispose();
+        }
+        this.hasPipelines &&
+            this.pipelines.isDisposedSet() &&
+            this.pipelines.disposed.pipe(this);
+        this.hasObservers &&
+            this.observers.isDisposedSet() &&
+            this.observers.disposed.notify();
+        delete this._observers;
+        delete this._pipelines;
+        delete this._events;
+        delete this._context;
+        delete this._tags;
+    }
+    async addChildren(...nodes) {
+        for (const node of nodes) {
+            const newNode = await this.graph.addNode(node, this);
+            this.addChild(newNode);
+        }
+    }
+    parentTo(node) {
+        if (this.children.find((_) => NodeId.Compare(_.id, node.id)))
+            return;
+        this.parent?.removeChild(this.id);
+        node.addChild(this);
+        this.parent = node;
+        this.hasObservers &&
+            this.observers.isParentedSet() &&
+            node.observers.parented.notify();
+    }
+    addChild(node) {
+        if (this.children.find((_) => NodeId.Compare(_.id, node.id)))
+            return;
+        node.parent = this;
+        this.children.push(node);
+        this.hasObservers &&
+            this.observers.isChildAddedSet() &&
+            this.observers.childAdded.notify(node);
+        node.hasObservers &&
+            node.observers.isParentedSet() &&
+            node.observers.parented.notify();
+    }
+    removeChild(id) {
+        const index = this.children.findIndex((_) => _ && NodeId.Compare(id, _.id));
+        if (index !== -1) {
+            const child = this.children.splice(index, 1)[0];
+            this.hasObservers &&
+                this.observers.isChildRemovedSet() &&
+                this.observers.childRemoved.notify(child);
+            this.hasObservers &&
+                this.observers.isRemovedFromParentSet() &&
+                child.observers.removedFromParent.notify();
+            return child;
+        }
+        return null;
+    }
+    copy() {
+        const data = {
+            id: NodeId.Create().idString,
+            name: this.name,
+            state: this.state,
+            children: this.children.map((_) => _.copy()),
+            tags: (this.hasTags && this.tags.tags.map((_) => _.toJSON())) || undefined,
+            components: (this.hasComponents &&
+                this.components.components.map((_) => _.copy())) ||
+                undefined,
+        };
+        return ((this.hasPipelines &&
+            this.pipelines.isCopySet() &&
+            this.pipelines.copy.pipe(data)) ||
+            data);
+    }
+    toJSON() {
+        const data = {
+            id: NodeId.Create().idString,
+            name: this.name,
+            state: this.state,
+            children: this.children.map((_) => _.copy()),
+            tags: (this.hasTags && this.tags.tags.map((_) => _.toJSON())) || undefined,
+            components: (this.hasComponents &&
+                this.components.components.map((_) => _.copy())) ||
+                undefined,
+        };
+        return ((this.hasPipelines &&
+            this.pipelines.isToJSONSet() &&
+            this.pipelines.toJSON.pipe(data)) ||
+            data);
+    }
+}

package/Nodes/NodeObservers.d.ts

@@ -0,0 +1,24 @@
+import { Observable } from "@amodx/core/Observers";
+import { NodeInstance } from "./NodeInstance";
+export interface NodeObservers {
+}
+export declare class NodeObservers {
+    private _disposed?;
+    private _parented?;
+    private _removedFromParent?;
+    private _childAdded?;
+    private _childRemoved?;
+    private _childrenUpdated?;
+    get disposed(): Observable<void>;
+    get parented(): Observable<void>;
+    get removedFromParent(): Observable<void>;
+    get childAdded(): Observable<NodeInstance>;
+    get childRemoved(): Observable<NodeInstance>;
+    get childrenUpdated(): Observable<void>;
+    isDisposedSet(): boolean;
+    isParentedSet(): boolean;
+    isRemovedFromParentSet(): boolean;
+    isChildAddedSet(): boolean;
+    isChildRemovedSet(): boolean;
+    isChildrenUpdatedSet(): boolean;
+}

package/Nodes/NodeObservers.js

@@ -0,0 +1,63 @@
+import { Observable } from "@amodx/core/Observers";
+export class NodeObservers {
+    _disposed;
+    _parented;
+    _removedFromParent;
+    _childAdded;
+    _childRemoved;
+    _childrenUpdated;
+    get disposed() {
+        if (!this._disposed) {
+            this._disposed = new Observable();
+        }
+        return this._disposed;
+    }
+    get parented() {
+        if (!this._parented) {
+            this._parented = new Observable();
+        }
+        return this._parented;
+    }
+    get removedFromParent() {
+        if (!this._removedFromParent) {
+            this._removedFromParent = new Observable();
+        }
+        return this._removedFromParent;
+    }
+    get childAdded() {
+        if (!this._childAdded) {
+            this._childAdded = new Observable();
+        }
+        return this._childAdded;
+    }
+    get childRemoved() {
+        if (!this._childRemoved) {
+            this._childRemoved = new Observable();
+        }
+        return this._childRemoved;
+    }
+    get childrenUpdated() {
+        if (!this._childrenUpdated) {
+            this._childrenUpdated = new Observable();
+        }
+        return this._childrenUpdated;
+    }
+    isDisposedSet() {
+        return !!this._disposed;
+    }
+    isParentedSet() {
+        return !!this._parented;
+    }
+    isRemovedFromParentSet() {
+        return !!this._removedFromParent;
+    }
+    isChildAddedSet() {
+        return !!this._childAdded;
+    }
+    isChildRemovedSet() {
+        return !!this._childRemoved;
+    }
+    isChildrenUpdatedSet() {
+        return !!this._childrenUpdated;
+    }
+}

package/Nodes/NodePipelines.d.ts

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

package/Nodes/NodePipelines.js

@@ -0,0 +1,33 @@
+import { Pipeline } from "@amodx/core/Pipelines";
+export class NodePipelines {
+    _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/Nodes/Tags/NodeTagObservers.d.ts

@@ -0,0 +1,15 @@
+import { Observable } from "@amodx/core/Observers";
+import { TagInstance } from "../../Tags/TagInstance";
+export interface NodeTagObservers {
+}
+export declare class NodeTagObservers {
+    private _tagAdded?;
+    private _tagRemoved?;
+    private _tagsUpdated?;
+    get tagsAdded(): Observable<TagInstance>;
+    get tagsRemoved(): Observable<TagInstance>;
+    get tagsUpdated(): Observable<void>;
+    isTagsAddedSet(): boolean;
+    isTagsRemovedSet(): boolean;
+    isTagsUpdatedSet(): boolean;
+}

package/Nodes/Tags/NodeTagObservers.js

@@ -0,0 +1,33 @@
+import { Observable } from "@amodx/core/Observers";
+export class NodeTagObservers {
+    _tagAdded;
+    _tagRemoved;
+    _tagsUpdated;
+    get tagsAdded() {
+        if (!this._tagAdded) {
+            this._tagAdded = new Observable();
+        }
+        return this._tagAdded;
+    }
+    get tagsRemoved() {
+        if (!this._tagRemoved) {
+            this._tagRemoved = new Observable();
+        }
+        return this._tagRemoved;
+    }
+    get tagsUpdated() {
+        if (!this._tagsUpdated) {
+            this._tagsUpdated = new Observable();
+        }
+        return this._tagsUpdated;
+    }
+    isTagsAddedSet() {
+        return !!this._tagAdded;
+    }
+    isTagsRemovedSet() {
+        return !!this._tagRemoved;
+    }
+    isTagsUpdatedSet() {
+        return !!this._tagsUpdated;
+    }
+}

package/Nodes/Tags/NodeTags.d.ts

@@ -0,0 +1,21 @@
+import { NodeInstance } from "../NodeInstance";
+import { NodeTagObservers } from "./NodeTagObservers";
+import { TagInstance } from "../../Tags/TagInstance";
+import { TagData } from "../../Tags/TagData";
+export declare class NodeTags {
+    node: NodeInstance;
+    private _observers?;
+    get observers(): NodeTagObservers;
+    get hasObservers(): boolean;
+    tags: TagInstance[];
+    constructor(node: NodeInstance);
+    dispose(): void;
+    add(tag: TagData): TagInstance;
+    addTags(...components: TagData[]): void;
+    remove(type: string): boolean;
+    get(type: string): TagInstance | null;
+    getChild(type: string): TagInstance | null;
+    getAllChildlren(type: string): TagInstance[];
+    getParent(type: string): TagInstance | null;
+    getAllParents(type: string): TagInstance[];
+}