@amodx/ncs 0.0.1 → 0.0.21

package/Contexts/ContextData.d.ts

@@ -1,59 +0,0 @@
-/**
- * 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/ContextInstance.d.ts

@@ -1,14 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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/GraphEvents.d.ts

@@ -1,9 +0,0 @@
-import { NodeEventCursor } from "../Nodes/NodeEvents";
-export declare class GraphEvents {
-    private events;
-    hasListener(id: string): boolean;
-    clearListeners(id: string): false | undefined;
-    addListener(id: string, run: (data: NodeEventCursor) => void): void;
-    removeListener(id: string, run: Function): boolean;
-    dispatch<Data>(id: string, data: NodeEventCursor): boolean;
-}

package/Graphs/GraphEvents.js

@@ -1,35 +0,0 @@
-import { Observable } from "@amodx/core/Observers";
-export class GraphEvents {
-    events = new Map();
-    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);
-        }
-        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);
-        return true;
-    }
-}

package/Graphs/GraphObservers.d.ts

@@ -1,9 +0,0 @@
-import { Observable } from "@amodx/core/Observers";
-import { NodeInstance } from "../Nodes/NodeInstance";
-export interface GraphObservers {
-}
-export declare class GraphObservers {
-    nodeAdded: Observable<NodeInstance>;
-    nodeRemoved: Observable<NodeInstance>;
-    nodesUpdated: Observable<void>;
-}

package/Graphs/GraphObservers.js

@@ -1,6 +0,0 @@
-import { Observable } from "@amodx/core/Observers";
-export class GraphObservers {
-    nodeAdded = new Observable();
-    nodeRemoved = new Observable();
-    nodesUpdated = new Observable();
-}

package/Graphs/GraphUpdate.d.ts

@@ -1,13 +0,0 @@
-import { SystemInstance } from "../Systems/SystemInstance";
-import { ComponentInstance } from "../Components/ComponentInstance";
-import { Graph } from "./Graph";
-export declare class GraphUpdate {
-    private static updatingComponents;
-    static addComponentToUpdate(component: ComponentInstance<any, any, any, any>): void;
-    static removeComponentFromUpate(component: ComponentInstance<any, any, any, any>): void;
-    static getUpdatingComponents(graph: Graph): Set<ComponentInstance<{}, {}, {}, {}>>;
-    private static updatingSystems;
-    static addSystemToUpdate(system: SystemInstance): void;
-    static removeSystemFromUpdate(system: SystemInstance): void;
-    static getUpdatingSystems(graph: Graph): Set<SystemInstance>;
-}

package/Graphs/GraphUpdate.js

@@ -1,38 +0,0 @@
-export class GraphUpdate {
-    static updatingComponents = new Map();
-    static addComponentToUpdate(component) {
-        let updating = this.updatingComponents.get(component.node.graph);
-        if (!updating) {
-            updating = new Set();
-            this.updatingComponents.set(component.node.graph, updating);
-        }
-        updating.add(component);
-    }
-    static removeComponentFromUpate(component) {
-        let updating = this.updatingComponents.get(component.node.graph);
-        if (!updating)
-            return;
-        updating.delete(component);
-    }
-    static getUpdatingComponents(graph) {
-        return this.updatingComponents.get(graph);
-    }
-    static updatingSystems = new Map();
-    static addSystemToUpdate(system) {
-        let updating = this.updatingSystems.get(system.graph);
-        if (!updating) {
-            updating = new Set();
-            this.updatingSystems.set(system.graph, updating);
-        }
-        updating.add(system);
-    }
-    static removeSystemFromUpdate(system) {
-        let updating = this.updatingSystems.get(system.graph);
-        if (!updating)
-            return;
-        updating.delete(system);
-    }
-    static getUpdatingSystems(graph) {
-        return this.updatingSystems.get(graph);
-    }
-}

package/Maps/ItemGraphMap.d.ts

@@ -1,11 +0,0 @@
-import { NodeInstance } from "../Nodes/NodeInstance";
-import { Graph } from "../Graphs/Graph";
-import { ItemNodeMap } from "../Maps/ItemNodeMap";
-export declare class ItemGraphMap<MappedItem> {
-    private graphs;
-    getMap(graph: Graph): ItemNodeMap<MappedItem>;
-    addNode(node: NodeInstance, item: MappedItem): void;
-    removeNode(node: NodeInstance, item: MappedItem): void;
-    getNodes(graph: Graph): Set<NodeInstance>;
-    getItems(graph: Graph): Set<MappedItem>;
-}

package/Maps/ItemGraphMap.js

@@ -1,30 +0,0 @@
-import { ItemNodeMap } from "../Maps/ItemNodeMap";
-export class ItemGraphMap {
-    graphs = new Map();
-    getMap(graph) {
-        let graphMap = this.graphs.get(graph);
-        if (!graphMap) {
-            graphMap = new ItemNodeMap();
-            this.graphs.set(graph, graphMap);
-        }
-        return graphMap;
-    }
-    addNode(node, item) {
-        const graphMap = this.getMap(node.graph);
-        graphMap.addNode(node, item);
-    }
-    removeNode(node, item) {
-        if (!this.graphs.has(node.graph))
-            return;
-        const graphMap = this.getMap(node.graph);
-        graphMap.addNode(node, item);
-    }
-    getNodes(graph) {
-        const graphMap = this.getMap(graph);
-        return graphMap.getNodes();
-    }
-    getItems(graph) {
-        const graphMap = this.getMap(graph);
-        return graphMap.getItems();
-    }
-}

package/Maps/ItemNodeMap.d.ts

@@ -1,17 +0,0 @@
-import { Observable } from "@amodx/core/Observers";
-import { NodeInstance } from "../Nodes/NodeInstance";
-declare class NodeGraphMapObservers {
-    nodeAdded: Observable<NodeInstance>;
-    nodeRemoved: Observable<NodeInstance>;
-}
-export declare class ItemNodeMap<MappedItem> {
-    private nodes;
-    private items;
-    private nodeMap;
-    observers: NodeGraphMapObservers;
-    addNode(node: NodeInstance, mappedItem: MappedItem): void;
-    removeNode(node: NodeInstance, mappedItem: MappedItem): void;
-    getNodes(): Set<NodeInstance>;
-    getItems(): Set<MappedItem>;
-}
-export {};

package/Maps/ItemNodeMap.js

@@ -1,41 +0,0 @@
-import { Observable } from "@amodx/core/Observers";
-class NodeGraphMapObservers {
-    nodeAdded = new Observable();
-    nodeRemoved = new Observable();
-}
-export class ItemNodeMap {
-    nodes = new Set();
-    items = new Set();
-    nodeMap = new Map();
-    observers = new NodeGraphMapObservers();
-    addNode(node, mappedItem) {
-        this.nodes.add(node);
-        this.items.add(mappedItem);
-        let mapped = this.nodeMap.get(node);
-        if (!mapped) {
-            mapped = [];
-            this.nodeMap.set(node, mapped);
-        }
-        mapped.push(mappedItem);
-        this.observers.nodeAdded.notify(node);
-    }
-    removeNode(node, mappedItem) {
-        this.nodes.delete(node);
-        this.items.delete(mappedItem);
-        let mapped = this.nodeMap.get(node);
-        if (!mapped)
-            return;
-        mapped = mapped.filter((_) => _ != mappedItem);
-        if (!mapped.length) {
-            this.nodeMap.delete(node);
-            this.nodes.delete(node);
-            this.observers.nodeRemoved.notify(node);
-        }
-    }
-    getNodes() {
-        return this.nodes;
-    }
-    getItems() {
-        return this.items;
-    }
-}

package/Nodes/Components/NodeComponentObservers.d.ts

@@ -1,15 +0,0 @@
-import { Observable } from "@amodx/core/Observers";
-import { ComponentInstance } from "../../Components/ComponentInstance";
-export interface NodeComponentObservers {
-}
-export declare class NodeComponentObservers {
-    private _componentAdded?;
-    private _componentRemoved?;
-    private _componentsUpdated?;
-    get componentAdded(): Observable<ComponentInstance<any>>;
-    get componentRemoved(): Observable<ComponentInstance<any>>;
-    get componentsUpdated(): Observable<void>;
-    isComponentAddedSet(): boolean;
-    isComponentRemovedSet(): boolean;
-    isComponentsUpdatedSet(): boolean;
-}

package/Nodes/Components/NodeComponentObservers.js

@@ -1,33 +0,0 @@
-import { Observable } from "@amodx/core/Observers";
-export class NodeComponentObservers {
-    _componentAdded;
-    _componentRemoved;
-    _componentsUpdated;
-    get componentAdded() {
-        if (!this._componentAdded) {
-            this._componentAdded = new Observable();
-        }
-        return this._componentAdded;
-    }
-    get componentRemoved() {
-        if (!this._componentRemoved) {
-            this._componentRemoved = new Observable();
-        }
-        return this._componentRemoved;
-    }
-    get componentsUpdated() {
-        if (!this._componentsUpdated) {
-            this._componentsUpdated = new Observable();
-        }
-        return this._componentsUpdated;
-    }
-    isComponentAddedSet() {
-        return !!this._componentAdded;
-    }
-    isComponentRemovedSet() {
-        return !!this._componentRemoved;
-    }
-    isComponentsUpdatedSet() {
-        return !!this._componentsUpdated;
-    }
-}

package/Nodes/Components/NodeComponents.d.ts

@@ -1,22 +0,0 @@
-import { NodeInstance } from "../NodeInstance";
-import { ComponentData } from "../../Components/ComponentData";
-import { ComponentInstance } from "../../Components/ComponentInstance";
-import { NodeComponentObservers } from "./NodeComponentObservers";
-export declare class NodeComponents {
-    node: NodeInstance;
-    private _observers?;
-    get observers(): NodeComponentObservers;
-    get hasObservers(): boolean;
-    components: ComponentInstance[];
-    constructor(node: NodeInstance);
-    dispose(): Promise<void>;
-    add(comp: ComponentData, init?: boolean): Promise<ComponentInstance<any, any, any, any>>;
-    addComponents(...components: ComponentData[]): Promise<void>;
-    removeByIndex(index: number): Promise<boolean>;
-    remove(type: string): Promise<boolean>;
-    get(type: string): ComponentInstance<any, any, any, any> | null;
-    getAll(type: string): ComponentInstance<any, any, any, any>[];
-    removeAll(type: string): Promise<ComponentInstance<any, any, any, any>[]>;
-    getChild(type: string): ComponentInstance<any, any, any, any> | null;
-    getParent(type: string): ComponentInstance<any, any, any, any> | null;
-}

package/Nodes/Components/NodeComponents.js

@@ -1,107 +0,0 @@
-import { NodeComponentObservers } from "./NodeComponentObservers";
-import { NCSRegister } from "../../Register/NCSRegister";
-export class NodeComponents {
-    node;
-    _observers;
-    get observers() {
-        if (!this._observers) {
-            this._observers = new NodeComponentObservers();
-        }
-        return this._observers;
-    }
-    get hasObservers() {
-        return Boolean(this._observers);
-    }
-    components = [];
-    constructor(node) {
-        this.node = node;
-    }
-    async dispose() {
-        for (const comp of this.components) {
-            await comp.dispose();
-        }
-    }
-    async add(comp, init = true) {
-        const compType = NCSRegister.components.get(comp.type, comp.namespace || "main");
-        const newComponent = compType.create(this.node, comp);
-        this.components.push(newComponent);
-        if (init)
-            await newComponent.init();
-        if (comp.traits.length) {
-            await newComponent.traits.addTraits(...comp.traits);
-        }
-        this.hasObservers &&
-            this.observers.isComponentAddedSet() &&
-            this.hasObservers &&
-            this.observers.componentAdded.notify(newComponent);
-        return newComponent;
-    }
-    async addComponents(...components) {
-        const newComponents = [];
-        for (const comp of components) {
-            newComponents.push(await this.add(comp, false));
-        }
-        for (const comp of newComponents) {
-            await comp.init();
-        }
-        this.hasObservers &&
-            this.observers.isComponentsUpdatedSet() &&
-            this.observers.componentsUpdated.notify();
-    }
-    async removeByIndex(index) {
-        const component = this.components[index];
-        if (component) {
-            const child = this.components.splice(index, 1)[0];
-            this.hasObservers &&
-                this.observers.isComponentRemovedSet() &&
-                this.observers.componentRemoved.notify(child);
-            this.hasObservers &&
-                this.observers.isComponentsUpdatedSet() &&
-                this.observers.componentsUpdated.notify();
-            await component.dispose();
-            return true;
-        }
-        return false;
-    }
-    remove(type) {
-        return this.removeByIndex(this.components.findIndex((_) => _.type == type));
-    }
-    get(type) {
-        return this.components.find((_) => _.type == type) || null;
-    }
-    getAll(type) {
-        return this.components.filter((_) => _.type == type);
-    }
-    async removeAll(type) {
-        const filtered = this.getAll(type);
-        this.components = this.components.filter((_) => _.type != type);
-        for (const comp of filtered) {
-            await comp.dispose();
-        }
-        for (const comp of filtered) {
-            this.hasObservers &&
-                this.observers.isComponentRemovedSet() &&
-                this.observers.componentRemoved.notify(comp);
-        }
-        this.hasObservers &&
-            this.observers.isComponentsUpdatedSet() &&
-            this.observers.componentsUpdated.notify();
-        return filtered;
-    }
-    getChild(type) {
-        for (const child of this.node.traverseChildren()) {
-            const found = child.components.get(type);
-            if (found)
-                return found;
-        }
-        return null;
-    }
-    getParent(type) {
-        for (const parent of this.node.traverseParents()) {
-            const found = parent.components.get(type);
-            if (found)
-                return found;
-        }
-        return null;
-    }
-}

package/Nodes/Context/NodeContext.d.ts

@@ -1,13 +0,0 @@
-import { ContextInstance } from "../../Contexts/ContextInstance";
-import { NodeInstance } from "../NodeInstance";
-import { ContextAnchorInstance } from "../../Contexts/ContextInstanceAnchor";
-import { ContextData } from "../../Contexts/ContextData";
-export declare class NodeContext {
-    node: NodeInstance;
-    contexts: Map<string, ContextInstance<{}, {}>>;
-    anchors: Map<string, ContextAnchorInstance<{}, {}>>;
-    constructor(node: NodeInstance);
-    add(context: ContextData): ContextInstance<{}, {}> | ContextInstance<any, any>;
-    remove(type: string): ContextInstance<{}, {}> | undefined;
-    get(type: string): ContextInstance | ContextAnchorInstance | null;
-}

package/Nodes/Context/NodeContext.js

@@ -1,45 +0,0 @@
-import { ContextInstance } from "../../Contexts/ContextInstance";
-import { ContextAnchorInstance } from "../../Contexts/ContextInstanceAnchor";
-import { NCSRegister } from "../../Register/NCSRegister";
-export class NodeContext {
-    node;
-    contexts = new Map();
-    anchors = new Map();
-    constructor(node) {
-        this.node = node;
-    }
-    add(context) {
-        if (this.contexts.has(context.type)) {
-            return this.contexts.get(context.type);
-        }
-        const newContext = new ContextInstance(this.node, NCSRegister.contexts.get(context.type, context.namespace || "main"), context);
-        this.contexts.set(context.type, newContext);
-        return newContext;
-    }
-    remove(type) {
-        const context = this.contexts.get(type);
-        if (!context)
-            return;
-        this.contexts.delete(type);
-        return context;
-    }
-    get(type) {
-        if (this.contexts.has(type))
-            return this.contexts.get(type);
-        if (this.anchors.has(type))
-            return this.anchors.get(type);
-        for (const parent of this.node.traverseParents()) {
-            if (parent.hasContexts) {
-                const found = parent.context.get(type);
-                if (found) {
-                    const newAnchor = found instanceof ContextInstance
-                        ? new ContextAnchorInstance(this.node, found)
-                        : new ContextAnchorInstance(this.node, found.getContext());
-                    this.anchors.set(type, newAnchor);
-                    return newAnchor;
-                }
-            }
-        }
-        return null;
-    }
-}