@elicdavis/node-flow 0.1.0

package/src/nodes/factory.ts

@@ -0,0 +1,87 @@
+import { FlowNode } from "../node";
+import { Publisher, PublisherConfig } from "./publisher";
+import { ContextMenuConfig } from "../contextMenu";
+import { Vector2 } from "../types/vector2";
+import { nodeFlowGroup as nodeFlowContextMenuGroup, NodeSubsystem } from "./subsystem";
+
+export type NodeCreatedCallback = (publisher: string, nodeType: string, node: FlowNode) => void;
+
+interface NodeFactoryPublishers {
+    [name: string]: PublisherConfig
+}
+
+export interface NodeFactoryConfig {
+    publishers?: NodeFactoryPublishers
+    onNodeCreated?: NodeCreatedCallback;
+}
+
+export class NodeFactory {
+    #registeredPublishers: Map<string, Publisher>;
+
+    #registeredCallbacks: Array<NodeCreatedCallback>;
+
+    constructor(config?: NodeFactoryConfig) {
+        this.#registeredPublishers = new Map<string, Publisher>();
+        this.#registeredCallbacks = new Array<NodeCreatedCallback>();
+
+        if (config?.onNodeCreated) {
+            this.#registeredCallbacks.push(config?.onNodeCreated);
+        }
+
+        if (config?.publishers !== undefined) {
+            for (let entry in config.publishers) {
+                this.addPublisher(entry, new Publisher(config.publishers[entry]));
+            }
+        }
+    }
+
+    public addOnNodeCreatedListener(callback: NodeCreatedCallback): void {
+        this.#registeredCallbacks.push(callback);
+    }
+
+    public addPublisher(identifier: string, publisher: Publisher): void {
+        this.#registeredPublishers.set(identifier, publisher);
+    }
+
+    // I'm not even sure if I want this here? You can register on Publishers...
+    // So why not just make people register with the publisher.
+    // public register(publisher: string, nodeType: string, config: FlowNodeConfiguration): void {
+    //     const foundPublisher = this.#registeredPublishers.get(publisher);
+    //     if (foundPublisher === undefined) {
+    //         console.error("no publisher registered with identifier:" + publisher);
+    //         return;
+    //     }
+
+    //     foundPublisher.register(nodeType, config);
+    // }
+
+    public create(publisher: string, nodeType: string): FlowNode {
+        const publisherIdentifier = this.#registeredPublishers.get(publisher)
+        if (publisherIdentifier === undefined) {
+            throw new Error("no publisher registered with identifier: " + publisher);
+        }
+        const node = publisherIdentifier.create(nodeType);
+
+        for (let i = 0; i < this.#registeredCallbacks.length; i++) {
+            const callback = this.#registeredCallbacks[i];
+            callback(publisher, nodeType, node);
+        }
+        return node;
+    }
+
+    public newNodeSubmenus(graph: NodeSubsystem, position: Vector2): Array<ContextMenuConfig> {
+        const menus: Array<ContextMenuConfig> = [];
+        for (let [_, publisher] of this.#registeredPublishers) {
+            menus.push(publisher.contextMenu(graph, position))
+        }
+        return menus;
+    }
+
+    public openMenu(graph: NodeSubsystem, position: Vector2): ContextMenuConfig {
+        return {
+            name: "New Node",
+            group: nodeFlowContextMenuGroup,
+            subMenus: this.newNodeSubmenus(graph, position),
+        };
+    }
+} 

package/src/nodes/publisher.ts

@@ -0,0 +1,98 @@
+import { ContextMenuConfig, ContextMenuItemConfig } from "../contextMenu";
+import { FlowNode, FlowNodeConfig } from '../node';
+import { Vector2 } from "../types/vector2";
+import { NodeSubsystem } from "./subsystem";
+
+interface PublisherNodes {
+    [name: string]: FlowNodeConfig
+}
+
+export interface PublisherConfig {
+    name?: string;
+    description?: string;
+    version?: string;
+    nodes?: PublisherNodes
+}
+
+export class Publisher {
+
+    #name: string;
+
+    #description: string;
+
+    #version: string;
+
+    #registeredNodes: Map<string, FlowNodeConfig>
+
+    constructor(config?: PublisherConfig) {
+        this.#name = config?.name === undefined ? "Unknown" : config.name;
+        this.#description = config?.description === undefined ? "" : config.description;
+        this.#version = config?.version === undefined ? "v0.0.0" : config.version;
+
+        this.#registeredNodes = new Map<string, FlowNodeConfig>();
+
+        if (config?.nodes !== undefined) {
+            for (const nodeKey in config.nodes) {
+                this.register(nodeKey, config.nodes[nodeKey]);
+            }
+        }
+    }
+
+    nodes(): Map<string, FlowNodeConfig> {
+        return this.#registeredNodes;
+    }
+
+    register(nodeType: string, config: FlowNodeConfig): void {
+        this.#registeredNodes.set(nodeType, config);
+    }
+
+    #recurseBuildMenu(graph: NodeSubsystem, name: string, subMenu: Map<string, FlowNodeConfig>, position: Vector2): ContextMenuConfig {
+        const items: Array<ContextMenuItemConfig> = [];
+        const subMenus = new Map<string, Map<string, FlowNodeConfig>>();
+
+        for (let [key, nodeConfig] of subMenu) {
+            const elements = key.split("/");
+            if (elements.length === 1) {
+                items.push({
+                    name: key,
+                    callback: () => {
+                        const node = new FlowNode(nodeConfig);
+                        node.setPosition(position);
+                        graph.addNode(node);
+                    },
+                });
+            } else {
+                if (!subMenus.has(elements[0])) {
+                    subMenus.set(elements[0], new Map<string, FlowNodeConfig>());
+                }
+
+                const menu = subMenus.get(elements[0]);
+                elements.shift();
+                menu?.set(elements.join("/"), nodeConfig)
+            }
+        }
+
+        const menus: Array<ContextMenuConfig> = [];
+        for (let [key, nodes] of subMenus) {
+            menus.push(this.#recurseBuildMenu(graph, key, nodes, position))
+        }
+
+        return {
+            name: name,
+            items: items,
+            subMenus: menus
+        }
+    }
+
+    contextMenu(graph: NodeSubsystem, position: Vector2): ContextMenuConfig {
+        return this.#recurseBuildMenu(graph, this.#name, this.#registeredNodes, position);
+    }
+
+    create(nodeType: string): FlowNode {
+        const config = this.#registeredNodes.get(nodeType)
+        if (config === undefined) {
+            throw new Error("no builder registered for node: " + nodeType);
+        }
+        return new FlowNode(config);
+    }
+}