@amodx/ncs 0.0.1

package/Graphs/Graph.js

@@ -0,0 +1,90 @@
+import { NodeInstance } from "../Nodes/NodeInstance";
+import { NodeId } from "../Nodes/NodeId";
+import { GraphEvents } from "./GraphEvents";
+import { Node } from "../NCS";
+import { GraphUpdate } from "./GraphUpdate";
+import { GraphObservers } from "./GraphObservers";
+export class Graph {
+    dependencies;
+    _nodeMap = new Map();
+    events = new GraphEvents();
+    observers = new GraphObservers();
+    root = new NodeInstance(null, Node({ name: "__root__" }), this);
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    getNode(id) {
+        if (typeof id == "string")
+            id = NodeId.Create(id);
+        const high = this._nodeMap.get(id.low);
+        if (!high)
+            throw new Error(`Node with id ${id.idString} does not exist`);
+        const node = high.get(id.high);
+        if (!node)
+            throw new Error(`Node with id ${id.idString} does not exist`);
+        return node;
+    }
+    async loadInRoot(data) {
+        if (this.root)
+            this.root.dispose();
+        const root = new NodeInstance({}, data, this);
+        await root.addChildren(...data.children);
+        this.root = root;
+    }
+    async addNode(data, parent = this.root) {
+        const newNode = new NodeInstance(parent, data, this);
+        newNode.parent = parent;
+        parent.children.push(newNode);
+        let high = this._nodeMap.get(newNode.id.low);
+        if (!high) {
+            high = new Map();
+            this._nodeMap.set(newNode.id.low, high);
+        }
+        high.set(newNode.id.high, newNode);
+        if (data.components?.length) {
+            await newNode.components.addComponents(...data.components);
+        }
+        parent.hasObservers &&
+            parent.observers.isChildAddedSet() &&
+            parent.observers.childAdded.notify(newNode);
+        this.observers.nodeAdded.notify(newNode);
+        this.observers.nodesUpdated.notify();
+        if (data.children?.length) {
+            for (const child of data.children) {
+                await this.addNode(child, newNode);
+            }
+        }
+        return newNode;
+    }
+    removeNode(id) {
+        const low = this._nodeMap.get(id.low);
+        if (!low)
+            return;
+        const node = low.get(id.high);
+        if (!node)
+            return;
+        if (!node.isDisposed())
+            node.dispose();
+        this._nodeMap.delete(id.low);
+        low.delete(id.high);
+        this.observers.nodeRemoved.notify(node);
+        this.observers.nodesUpdated.notify();
+    }
+    update() {
+        {
+            const updating = GraphUpdate.getUpdatingComponents(this);
+            for (const component of updating) {
+                component.componentPrototype.data.update(component);
+            }
+        }
+        {
+            const updating = GraphUpdate.getUpdatingSystems(this);
+            for (const system of updating) {
+                system.systemPrototype.update(system);
+            }
+        }
+    }
+    toJSON() {
+        return this.root.toJSON();
+    }
+}

package/Graphs/GraphEvents.d.ts

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

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

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

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

package/Graphs/GraphUpdate.d.ts

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

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

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

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

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

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

@@ -0,0 +1,54 @@
+import { Pipeline } from "@amodx/core/Pipelines";
+import { Graph, GraphDependencies } from "./Graphs/Graph";
+import { NodeData, NodeStateData } from "./Nodes/NodeData";
+import { NodeInstance } from "./Nodes/NodeInstance";
+import { QueryData } from "./Queries/QueryData";
+import { QueryPrototype } from "./Queries/QueryPrototype";
+import { ComponentData } from "./Components/ComponentData";
+import { TraitData } from "./Traits/TraitData";
+import { ContextData } from "./Contexts/ContextData";
+import { TagData } from "./Tags/TagData";
+import { registerContext } from "./Register/registerContext";
+import { registerTrait } from "./Register/registerTrait";
+import { registerTag } from "./Register/registerTag";
+import { registerSystem } from "./Register/registerSystem";
+export declare class NCS {
+    static Pipelines: {
+        OnComponentDataCreate: Pipeline<ComponentData>;
+        OnTraitDataCreate: Pipeline<TraitData>;
+        OnNodeDataCreate: Pipeline<NodeData>;
+        OnContextDataCreate: Pipeline<ContextData>;
+        OnTagDataCreate: Pipeline<TagData>;
+    };
+    static createGraph(dependencies: GraphDependencies): Graph;
+    static createNode(name?: string | null, state?: NodeStateData | null, components?: ComponentData[], children?: NodeData[]): NodeData;
+    static createQuery(data: QueryData): QueryPrototype;
+    static registerSystem: typeof registerSystem;
+    static registerComponent: <ComponentSchema extends object = {}, Data extends object = {}, Logic extends object = {}, Shared extends object = {}>(data: import("./Components/ComponentData").ComponentRegisterData<ComponentSchema, Data, Logic, Shared>) => import("./Components/ComponentData").ComponentRegisterData<ComponentSchema, Data, Logic, Shared> & {
+        getNodes: (grpah: Graph) => Set<NodeInstance>;
+        getComponents: (grpah: Graph) => Set<import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared>>;
+        set: (node: NodeInstance, componentSchema?: Partial<ComponentSchema> | undefined, traits?: TraitData[], state?: import("./Components/ComponentData").ComponentStateData) => Promise<import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared>>;
+        get: (node: NodeInstance) => import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared> | null;
+        getChild: (node: NodeInstance) => import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared> | null;
+        getParent: (node: NodeInstance) => import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared> | null;
+        getAll: (node: NodeInstance) => import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared>[] | null;
+        remove: (node: NodeInstance) => Promise<import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared> | null>;
+        removeAll: (node: NodeInstance) => Promise<import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared>[] | null>;
+        nodeData: {
+            get: (node: NodeData) => ComponentData<ComponentSchema> | null;
+            set: (node: NodeData, componentSchema?: Partial<ComponentSchema> | undefined, traits?: TraitData[], state?: import("./Components/ComponentData").ComponentStateData) => void;
+            getAll: (node: NodeData) => ComponentData<ComponentSchema>[] | null;
+            remove: (node: NodeData) => ComponentData<ComponentSchema> | null;
+            removeAll: (node: NodeData) => ComponentData<ComponentSchema>[] | null;
+        };
+        prototype: import("./Components/ComponentPrototype").ComponentPrototype<ComponentSchema, Data, Logic, Shared>;
+        default: import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared>;
+    } & ((schema?: Partial<ComponentSchema> | null | undefined, state?: Partial<import("./Components/ComponentData").ComponentStateData> | null | undefined, ...traits: TraitData[]) => ComponentData<ComponentSchema>);
+    static registerTrait: typeof registerTrait;
+    static registerContext: typeof registerContext;
+    static registerTag: typeof registerTag;
+}
+export declare function Node(data: {
+    name?: string;
+    state?: NodeStateData;
+}, components?: ComponentData[], ...children: NodeData[]): NodeData;

package/NCS.js

@@ -0,0 +1,41 @@
+import { Pipeline } from "@amodx/core/Pipelines";
+import { Graph } from "./Graphs/Graph";
+import { NodeId } from "./Nodes/NodeId";
+import { QueryPrototype } from "./Queries/QueryPrototype";
+import { registerContext } from "./Register/registerContext";
+import { registerComponent } from "./Register/registerComponent";
+import { registerTrait } from "./Register/registerTrait";
+import { registerTag } from "./Register/registerTag";
+import { registerSystem } from "./Register/registerSystem";
+export class NCS {
+    static Pipelines = {
+        OnComponentDataCreate: new Pipeline(),
+        OnTraitDataCreate: new Pipeline(),
+        OnNodeDataCreate: new Pipeline(),
+        OnContextDataCreate: new Pipeline(),
+        OnTagDataCreate: new Pipeline(),
+    };
+    static createGraph(dependencies) {
+        return new Graph(dependencies);
+    }
+    static createNode(name, state, components = [], children = []) {
+        return NCS.Pipelines.OnNodeDataCreate.pipe({
+            id: NodeId.Create().idString,
+            components,
+            children,
+            name: name ? name : "",
+            state: state ? state : {},
+        });
+    }
+    static createQuery(data) {
+        return new QueryPrototype(data);
+    }
+    static registerSystem = registerSystem;
+    static registerComponent = registerComponent;
+    static registerTrait = registerTrait;
+    static registerContext = registerContext;
+    static registerTag = registerTag;
+}
+export function Node(data, components, ...children) {
+    return NCS.createNode(data.name, data.state, components, children);
+}

package/Nodes/Components/NodeComponentObservers.d.ts

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

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

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

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

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

@@ -0,0 +1,45 @@
+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;
+    }
+}