Merge remote-tracking branch 'origin/dev' into feat/save-load-nodes

src/pages/VisProgPage/visualProgrammingUI/GraphReducer.ts

@@ -1,188 +0,0 @@
-import {
-  type Edge,
-  getIncomers,
-  getOutgoers
-} from '@xyflow/react';
-import useFlowStore from "./VisProgStores.tsx";
-import type {
-  BehaviorProgram,
-  GoalData,
-  GoalReducer,
-  GraphPreprocessor,
-  NormData,
-  NormReducer,
-  OrderedPhases,
-  Phase,
-  PhaseReducer,
-  PreparedGraph,
-  PreparedPhase
-} from "./GraphReducerTypes.ts";
-import type {
-  AppNode,
-  GoalNode,
-  NormNode,
-  PhaseNode
-} from "./VisProgTypes.tsx";
-
-/**
- * Reduces the current graph inside the visual programming editor into a BehaviorProgram
- *
- * @param {GraphPreprocessor} graphPreprocessor
- * @param {PhaseReducer} phaseReducer
- * @param {NormReducer} normReducer
- * @param {GoalReducer} goalReducer
- * @returns {BehaviorProgram}
- */
-export default function graphReducer(
-  graphPreprocessor: GraphPreprocessor = defaultGraphPreprocessor,
-  phaseReducer: PhaseReducer = defaultPhaseReducer,
-  normReducer: NormReducer = defaultNormReducer,
-  goalReducer: GoalReducer = defaultGoalReducer
-) : BehaviorProgram {
-  const nodes: AppNode[] = useFlowStore.getState().nodes;
-  const edges: Edge[] = useFlowStore.getState().edges;
-  const preparedGraph: PreparedGraph = graphPreprocessor(nodes, edges);
-
-  return preparedGraph.map((preparedPhase: PreparedPhase) : Phase =>
-    phaseReducer(
-      preparedPhase,
-      normReducer,
-      goalReducer
-    ));
-};
-
-/**
- * reduces a single preparedPhase to a Phase object
- * the Phase object describes a single phase in a BehaviorProgram
- *
- * @param {PreparedPhase} phase
- * @param {NormReducer} normReducer
- * @param {GoalReducer} goalReducer
- * @returns {Phase}
- */
-export function defaultPhaseReducer(
-  phase: PreparedPhase,
-  normReducer: NormReducer = defaultNormReducer,
-  goalReducer: GoalReducer = defaultGoalReducer
-) : Phase {
-  return {
-    id: phase.phaseNode.id,
-    name: phase.phaseNode.data.label,
-    nextPhaseId: phase.nextPhaseId,
-    phaseData: {
-      norms: phase.connectedNorms.map(normReducer),
-      goals: phase.connectedGoals.map(goalReducer)
-    }
-  }
-}
-
-/**
- * the default implementation of the goalNode reducer function
- *
- * @param {GoalNode} node
- * @returns {GoalData}
- */
-function defaultGoalReducer(node: GoalNode) : GoalData {
-  return {
-    id: node.id,
-    name: node.data.label,
-    value: node.data.value
-  }
-}
-
-/**
- * the default implementation of the normNode reducer function
- *
- * @param {NormNode} node
- * @returns {NormData}
- */
-function defaultNormReducer(node: NormNode) :NormData {
-  return {
-    id: node.id,
-    name: node.data.label,
-    value: node.data.value
-  }
-}
-
-// Graph preprocessing functions:
-
-/**
- * Preprocesses the provide state of the behavior editor graph, preparing it for further processing in
- * the graphReducer function
- *
- * @param {AppNode[]} nodes
- * @param {Edge[]} edges
- * @returns {PreparedGraph}
- */
-export function defaultGraphPreprocessor(nodes: AppNode[], edges: Edge[]) : PreparedGraph {
-  const norms : NormNode[] = nodes.filter((node) => node.type === 'norm') as NormNode[];
-  const goals : GoalNode[] = nodes.filter((node) => node.type === 'goal') as GoalNode[];
-  const orderedPhases : OrderedPhases = orderPhases(nodes, edges);
-
-  return orderedPhases.phaseNodes.map((phase: PhaseNode) : PreparedPhase => {
-    const nextPhase = orderedPhases.connections.get(phase.id);
-      return {
-        phaseNode: phase,
-        nextPhaseId: nextPhase as string,
-        connectedNorms: getIncomers({id: phase.id}, norms,edges),
-        connectedGoals: getIncomers({id: phase.id}, goals,edges)
-      };
-    });
-}
-
-/**
- * orderPhases takes the state of the graph created by the editor and turns it into an OrderedPhases object.
- *
- * @param {AppNode[]} nodes
- * @param {Edge[]} edges
- * @returns {OrderedPhases}
- */
-export function orderPhases(nodes: AppNode[],edges: Edge[]) : OrderedPhases {
-  // find the first Phase node
-  const phaseNodes : PhaseNode[] = nodes.filter((node) => node.type === 'phase') as PhaseNode[];
-  const startNodeIndex = nodes.findIndex((node : AppNode):boolean  => {return (node.type === 'start');});
-  const firstPhaseNode = getOutgoers({ id: nodes[startNodeIndex].id },phaseNodes,edges);
-
-  // recursively adds the phase nodes to a list in the order they are connected in the graph
-  const nextPhase  = (
-    currentIndex: number,
-    { phaseNodes: phases, connections: connections} : OrderedPhases
-  ) : OrderedPhases => {
-    // get the current phase and the next phases;
-    const currentPhase = phases[currentIndex];
-    const nextPhaseNodes = getOutgoers(currentPhase,phaseNodes,edges);
-    const nextNodes = getOutgoers(currentPhase,nodes, edges);
-
-    // handles adding of the next phase to the chain, and error handle if an invalid state is received
-    if (nextPhaseNodes.length === 1 && nextNodes.length === 1) {
-      connections.set(currentPhase.id, nextPhaseNodes[0].id);
-      return nextPhase(phases.push(nextPhaseNodes[0] as PhaseNode) - 1, {phaseNodes: phases, connections: connections});
-    } else {
-      // handle erroneous states
-      if (nextNodes.length === 0){
-        throw new Error(`| INVALID PROGRAM | the source handle of "${currentPhase.id}" doesn't have any outgoing connections`);
-      } else {
-        if (nextNodes.length > 1) {
-          throw new Error(`| INVALID PROGRAM | the source handle of "${currentPhase.id}" connects to too many targets`);
-        } else {
-          if (nextNodes[0].type === "end"){
-            connections.set(currentPhase.id, "end");
-            // returns the final output of the function
-            return { phaseNodes: phases, connections: connections};
-          } else {
-            throw new Error(`| INVALID PROGRAM | the node "${nextNodes[0].id}" that "${currentPhase.id}" connects to is not a phase or end node`);
-          }
-        }
-      }
-    }
-  }
-  // initializes the Map describing the connections between phase nodes
-  // we need this Map to make sure we preserve this information,
-  // so we don't need to do checks on the entire set of edges in further stages of the reduction algorithm
-  const connections : Map<string, string> = new Map();
-
-  // returns an empty list if no phase nodes are present, otherwise returns an ordered list of phaseNodes
-  if (firstPhaseNode.length > 0) {
-      return nextPhase(0, {phaseNodes: [firstPhaseNode[0] as PhaseNode], connections: connections})
-  } else { return {phaseNodes: [], connections: connections} }
-}

src/pages/VisProgPage/visualProgrammingUI/GraphReducerTypes.ts

@@ -1,106 +0,0 @@
-import type {Edge} from "@xyflow/react";
-import type {AppNode, GoalNode, NormNode, PhaseNode} from "./VisProgTypes.tsx";
-
-
-/**
- * defines how a norm is represented in the simplified behavior program
-  */
-export type NormData = {
-  id: string;
-  name: string;
-  value: string;
-};
-
-/**
- * defines how a goal is represented in the simplified behavior program
- */
-export type GoalData = {
-  id: string;
-  name: string;
-  value: string;
-};
-
-/**
- * definition of a PhaseData object, it contains all phaseData that is relevant
- * for further processing and execution of a phase.
- */
-export type PhaseData = {
-  norms: NormData[];
-  goals: GoalData[];
-};
-
-/**
- * Describes a single phase within the simplified representation of a behavior program,
- *
- * Contains:
- * - the id of the described phase,
- * - the name of the described phase,
- * - the id of the next phase in the user defined behavior program
- * - the data property of the described phase node
- *
- * @NOTE at the moment the type definitions do not support branching programs,
- * if branching of phases is to be supported in the future, the type definition for Phase has to be updated
- */
-export type Phase = {
-  id: string;
-  name: string;
-  nextPhaseId: string;
-  phaseData: PhaseData;
-};
-
-/**
- * Describes a simplified behavior program as a list of Phase objects
- */
-export type BehaviorProgram = Phase[];
-
-
-
-export type NormReducer = (node: NormNode) => NormData;
-export type GoalReducer = (node: GoalNode) => GoalData;
-export type PhaseReducer = (
-  preparedPhase: PreparedPhase,
-  normReducer: NormReducer,
-  goalReducer: GoalReducer
-) => Phase;
-
-/**
- * contains:
- *
- * - list of phases, sorted based on position in chain between the start and end node
- * - a dictionary containing all outgoing connections,
- * to other phase or end nodes, for each phase node uses the id of the source node as key
- * and the id of the target node as value
- *
- */
-export type OrderedPhases = {
-  phaseNodes: PhaseNode[];
-  connections: Map<string, string>;
-};
-
-/**
- * A single prepared phase,
- * contains:
- * - the described phaseNode,
- * - the id of the next phaseNode or "end" for the end node
- * - a list of the normNodes that are connected to the described phase
- * - a list of the goalNodes that are connected to the described phase
- */
-export type PreparedPhase = {
-  phaseNode: PhaseNode;
-  nextPhaseId: string;
-  connectedNorms: NormNode[];
-  connectedGoals: GoalNode[];
-};
-
-/**
- * a list of PreparedPhase objects,
- * describes the preprocessed state of a program,
- * before the contents of the node
- */
-export type PreparedGraph = PreparedPhase[];
-
-export type GraphPreprocessor = (nodes: AppNode[], edges: Edge[]) => PreparedGraph;
-
-
-
-

src/pages/VisProgPage/visualProgrammingUI/NodeRegistry.ts

@@ -0,0 +1,82 @@
+import StartNode, { StartConnects, StartReduce } from "./nodes/StartNode";
+import EndNode, { EndConnects, EndReduce } from "./nodes/EndNode";
+import PhaseNode, { PhaseConnects, PhaseReduce } from "./nodes/PhaseNode";
+import NormNode, { NormConnects, NormReduce } from "./nodes/NormNode";
+import { EndNodeDefaults } from "./nodes/EndNode.default";
+import { StartNodeDefaults } from "./nodes/StartNode.default";
+import { PhaseNodeDefaults } from "./nodes/PhaseNode.default";
+import { NormNodeDefaults } from "./nodes/NormNode.default";
+import GoalNode, { GoalConnects, GoalReduce } from "./nodes/GoalNode";
+import { GoalNodeDefaults } from "./nodes/GoalNode.default";
+import TriggerNode, { TriggerConnects, TriggerReduce } from "./nodes/TriggerNode";
+import { TriggerNodeDefaults } from "./nodes/TriggerNode.default";
+
+/**
+ * The types of the nodes we have registered.
+ */
+export const NodeTypes = {
+  start: StartNode,
+  end: EndNode,
+  phase: PhaseNode,
+  norm: NormNode,
+  goal: GoalNode,
+  trigger: TriggerNode,
+};
+
+/**
+ * The default functions of the nodes we have registered.
+ * These are defined in the <node>.default.ts files.
+ */
+export const NodeDefaults = {
+  start: StartNodeDefaults,
+  end: EndNodeDefaults,
+  phase: PhaseNodeDefaults,
+  norm: NormNodeDefaults,
+  goal: GoalNodeDefaults,
+  trigger: TriggerNodeDefaults,
+};
+
+
+/**
+ * The reduce functions of the nodes we have registered.
+ */
+export const NodeReduces = {
+  start: StartReduce,
+  end: EndReduce,
+  phase: PhaseReduce,
+  norm: NormReduce,
+  goal: GoalReduce,
+  trigger: TriggerReduce,
+}
+
+
+/**
+ * The connection functionality of the nodes we have registered.
+ */
+export const NodeConnects = {
+  start: StartConnects,
+  end: EndConnects,
+  phase: PhaseConnects,
+  norm: NormConnects,
+  goal: GoalConnects,
+  trigger: TriggerConnects,
+}
+
+/**
+ * Functions that define whether a node should be deleted, currently constant only for start and end.
+ * Any node types that aren't mentioned are 'true', and can be deleted by default.
+ */
+export const NodeDeletes = {
+  start: () => false,
+  end: () => false,
+}
+
+/**
+ * Defines which types are variables in the phase node- 
+ * any node that is NOT mentioned here, is automatically seen as a variable of a phase.
+ */
+export const NodesInPhase = {
+  start: () => false,
+  end: () => false,
+  phase: () => false,
+}

src/pages/VisProgPage/visualProgrammingUI/VisProgStores.tsx

@@ -1,142 +1,135 @@
-import {create} from 'zustand';
+import { create } from 'zustand';
 import {
   applyNodeChanges,
   applyEdgeChanges,
   addEdge,
-  reconnectEdge, type Edge, type Connection
+  reconnectEdge,
+  type Node,
+  type Edge,
+  type XYPosition,
 } from '@xyflow/react';
+import type { FlowState } from './VisProgTypes';
+import { NodeDefaults, NodeConnects, NodeDeletes } from './NodeRegistry';
 
-import {type AppNode, type FlowState} from './VisProgTypes.tsx';
 
 /**
- * contains the nodes that are created when the editor is loaded,
- * should contain at least a start and an end node
+ * Create a node given the correct data
+ * @param type the type of the node to create
+ * @param id the id of the node to create
+ * @param position the position of the node to create
+ * @param data the data in the node to create
+ * @param deletable if this node should be able to be deleted IN ANY WAY POSSIBLE
+ * @constructor
  */
-const initialNodes = [
-  {
-    id: 'start',
-    type: 'start',
-    position: {x: 0, y: 0},
-    data: {label: 'start'}
-  },
-  {
-    id: 'phase-1',
-    type: 'phase',
-    position: {x: 0, y: 150},
-    data: {label: 'Generic Phase', number: 1},
-  },
-  {
-    id: 'end',
-    type: 'end',
-    position: {x: 0, y: 300},
-    data: {label: 'End'}
+function createNode(id: string, type: string, position: XYPosition, data: Record<string, unknown>, deletable? : boolean) {
+  const defaultData = NodeDefaults[type as keyof typeof NodeDefaults]
+  const newData = {
+      id: id,
+      type: type,
+      position: position,
+      data: data,
+      deletable: deletable,
   }
+  return {...defaultData, ...newData}
+}
+
+//* Initial nodes, created by using createNode. */
+const initialNodes : Node[] = [
+    createNode('start', 'start', {x: 100, y: 100}, {label: "Start"}, false),
+    createNode('end', 'end', {x: 500, y: 100}, {label: "End"}, false),
+    createNode('phase-1', 'phase',  {x:200, y:100}, {label: "Phase 1", children : []}),
+    createNode('norms-1', 'norm',  {x:-200, y:100}, {label: "Initial Norms", normList: ["Be a robot", "get good"]}),     
 ];
 
-/**
- * contains the initial edges that are created when the editor is loaded
- */
-const initialEdges = [
-  {
-    id: 'start-phase-1',
-    source: 'start',
-    target: 'phase-1',
-  },
-  {
-    id: 'phase-1-end',
-    source: 'phase-1',
-    target: 'end',
-  }
+// * Initial edges * /
+const initialEdges: Edge[] = [
+  { id: 'start-phase-1', source: 'start', target: 'phase-1' },
+  { id: 'phase-1-end', source: 'phase-1', target: 'end' },
 ];
 
+
 /**
- * The useFlowStore hook contains the implementation for editor functionality and state
- * we can use this inside our editor component to access the current state
- * and use any implemented functionality
+ * How we have defined the functions for our FlowState. 
+ * We have the normal functionality of a default FlowState with some exceptions to account for extra functionality.
+ * The biggest changes are in onConnect and onDelete, which we have given extra functionality based on the nodes defined functions.
  */
 const useFlowStore = create<FlowState>((set, get) => ({
   nodes: initialNodes,
   edges: initialEdges,
   edgeReconnectSuccessful: true,
-  onNodesChange: (changes) => {
-    set({
-      nodes: applyNodeChanges(changes, get().nodes)
-    });
-  },
-  onEdgesChange: (changes) => {
-    set({
-      edges: applyEdgeChanges(changes, get().edges)
-    });
-  },
-  // handles connection of newly created edges
-  onConnect: (connection) => {
-    set({
-      edges: addEdge(connection, get().edges)
-    });
-  },
-  // handles attempted reconnections of a previously disconnected edge
-  onReconnect: (oldEdge: Edge, newConnection: Connection) => {
-    get().edgeReconnectSuccessful = true;
-    set({
-      edges: reconnectEdge(oldEdge, newConnection, get().edges)
-    });
-  },
-  // Handles initiation of reconnection of edges that are manually disconnected from a node
-  onReconnectStart: () => {
-    set({
-      edgeReconnectSuccessful: false
-    });
-  },
-  // Drops the edge from the set of edges, removing it from the flow, if no successful reconnection occurred
-  onReconnectEnd: (_: unknown, edge: { id: string; }) => {
-    if (!get().edgeReconnectSuccessful) {
-      set({
-        edges: get().edges.filter((e) => e.id !== edge.id),
-      });
-    }
-    set({
-      edgeReconnectSuccessful: true
-    });
-  },
-  deleteNode: (nodeId: string) => {
-    set({
-      nodes: get().nodes.filter((n) => n.id !== nodeId),
-      edges: get().edges.filter((e) => e.source !== nodeId && e.target !== nodeId)
-    });
-  },
-  setNodes: (nodes) => {
-    set({nodes});
-  },
-  setEdges: (edges) => {
-    set({edges});
-  },
-/**
- * handles updating the data component of a node,
- * if the provided data object contains entries that aren't present in the updated node's data component
- * those entries are added to the data component,
- * entries that do exist within the node's data component,
- * are simply updated to contain the new value
- *
- * the data object
- * @param {string} nodeId
- * @param {object} data
- */
-  updateNodeData: (nodeId: string, data) => {
-    set({
-      nodes: get().nodes.map((node) : AppNode => {
-        if (node.id === nodeId) {
-          return {
-            ...node,
-            data: {
-              ...node.data,
-              ...data
-            }
-          };
-        } else { return node; }
-      })
-    });
-  }
-  }),
-);
 
-export default useFlowStore;
+  onNodesChange: (changes) =>
+  set({nodes: applyNodeChanges(changes, get().nodes)}),
+  onEdgesChange: (changes) => set({ edges: applyEdgeChanges(changes, get().edges) }),
+
+  onConnect: (connection) => {
+  const edges = addEdge(connection, get().edges);
+  const nodes = get().nodes;
+  // connection has: { source, sourceHandle, target, targetHandle }
+  // Let's find the source and target ID's.
+  const sourceNode = nodes.find((n) => n.id == connection.source);
+  const targetNode = nodes.find((n) => n.id == connection.target);
+  
+  // In case the nodes weren't found, return basic functionality.
+  if (sourceNode == undefined || targetNode == undefined || sourceNode.type == undefined || targetNode.type == undefined) {
+    set({ nodes, edges });
+    return;
+  }
+
+  // We should find out how their data changes by calling their respective functions.
+  const sourceConnectFunction = NodeConnects[sourceNode.type as keyof typeof NodeConnects]
+  const targetConnectFunction = NodeConnects[targetNode.type as keyof typeof NodeConnects]
+  
+  // We're going to have to update their data based on how they want to update it.
+  sourceConnectFunction(sourceNode, targetNode, true)
+  targetConnectFunction(targetNode, sourceNode, false)
+  set({ nodes, edges });
+},
+
+  onReconnect: (oldEdge, newConnection) => {
+    get().edgeReconnectSuccessful = true;
+    set({ edges: reconnectEdge(oldEdge, newConnection, get().edges) });
+  },
+
+  onReconnectStart: () => set({ edgeReconnectSuccessful: false }),
+  onReconnectEnd: (_evt, edge) => {
+    if (!get().edgeReconnectSuccessful) {
+      set({ edges: get().edges.filter((e) => e.id !== edge.id) });
+    }
+    set({ edgeReconnectSuccessful: true });
+  },
+
+  deleteNode: (nodeId) => {
+    // Let's find our node to check if they have a special deletion function
+    const ourNode = get().nodes.find((n)=>n.id==nodeId);
+    const ourFunction = Object.entries(NodeDeletes).find(([t])=>t==ourNode?.type)?.[1]
+    
+    // If there's no function, OR, our function tells us we can delete it, let's do so...
+    if (ourFunction == undefined || ourFunction()) {
+      set({
+      nodes: get().nodes.filter((n) => n.id !== nodeId),
+      edges: get().edges.filter((e) => e.source !== nodeId && e.target !== nodeId),
+      })}
+    },
+
+  
+  setNodes: (nodes) => set({ nodes }),
+  setEdges: (edges) => set({ edges }),
+
+  updateNodeData: (nodeId, data) => {
+    set({
+      nodes: get().nodes.map((node) => {
+        if (node.id === nodeId) {
+          node = { ...node, data: { ...node.data, ...data }};
+        }
+        return node;
+      }),
+    });
+  },
+
+  addNode: (node: Node) => {
+    set({ nodes: [...get().nodes, node] });
+  },
+}));
+
+export default useFlowStore;

src/pages/VisProgPage/visualProgrammingUI/VisProgTypes.tsx

@@ -1,47 +1,24 @@
-import {
-  type Edge,
-  type Node,
-  type OnNodesChange,
-  type OnEdgesChange,
-  type OnConnect,
-  type OnReconnect,
-} from '@xyflow/react';
+// VisProgTypes.ts
+import type { Edge, OnNodesChange, OnEdgesChange, OnConnect, OnReconnect, Node } from '@xyflow/react';
+import type { NodeTypes } from './NodeRegistry';
 
+export type AppNode = typeof NodeTypes
 
-type defaultNodeData = {
-  label: string;
-};
-
-export type StartNode = Node<defaultNodeData, 'start'>;
-export type EndNode = Node<defaultNodeData, 'end'>;
-export type GoalNode = Node<defaultNodeData & { value: string; }, 'goal'>;
-export type NormNode = Node<defaultNodeData & { value: string; }, 'norm'>;
-export type PhaseNode = Node<defaultNodeData & { number: number; }, 'phase'>;
-
-
-/**
- * a type meant to house different node types, currently not used
- * but will allow us to more clearly define nodeTypes when we implement
- * computation of the Graph inside the ReactFlow editor
- */
-export type AppNode = Node | StartNode | EndNode | NormNode | GoalNode | PhaseNode;
-
-
-/**
- * The type for the Zustand store object used to manage the state of the ReactFlow editor
- */
 export type FlowState = {
-  nodes: AppNode[];
+  nodes: Node[];
   edges: Edge[];
   edgeReconnectSuccessful: boolean;
+
   onNodesChange: OnNodesChange;
   onEdgesChange: OnEdgesChange;
   onConnect: OnConnect;
   onReconnect: OnReconnect;
   onReconnectStart: () => void;
   onReconnectEnd: (_: unknown, edge: { id: string }) => void;
+
   deleteNode: (nodeId: string) => void;
-  setNodes: (nodes: AppNode[]) => void;
+  setNodes: (nodes: Node[]) => void;
   setEdges: (edges: Edge[]) => void;
   updateNodeData: (nodeId: string, data: object) => void;
+  addNode: (node: Node) => void;
 };

src/pages/VisProgPage/visualProgrammingUI/components/DragDropSidebar.tsx

@@ -1,19 +1,9 @@
-import {useDraggable} from '@neodrag/react';
-import {
-  useReactFlow,
-  type XYPosition
-} from '@xyflow/react';
-import {
-  type ReactNode,
-  useCallback,
-  useRef,
-  useState
-} from 'react';
-import useFlowStore from "../VisProgStores.tsx";
-import styles from "../../VisProg.module.css"
-import type {AppNode, PhaseNode, NormNode} from "../VisProgTypes.tsx";
-
-
+import { useDraggable } from '@neodrag/react';
+import { useReactFlow, type XYPosition } from '@xyflow/react';
+import { type ReactNode, useCallback, useRef, useState } from 'react';
+import useFlowStore from '../VisProgStores';
+import styles from '../../VisProg.module.css';
+import { NodeDefaults, type NodeTypes } from '../NodeRegistry'
 
 /**
  * DraggableNodeProps dictates the type properties of a DraggableNode
@@ -21,41 +11,28 @@ import type {AppNode, PhaseNode, NormNode} from "../VisProgTypes.tsx";
 interface DraggableNodeProps {
   className?: string;
   children: ReactNode;
-  nodeType: string;
-  onDrop: (nodeType: string, position: XYPosition) => void;
+  nodeType: keyof typeof NodeTypes;
+  onDrop: (nodeType: keyof typeof NodeTypes, position: XYPosition) => void;
 }
 
 /**
- * Definition of a node inside the drag and drop toolbar,
- * these nodes require an onDrop function to be supplied
- * that dictates how the node is created in the graph.
- *
- * @param className
- * @param children
- * @param nodeType
- * @param onDrop
- * @constructor
+ * Definition of a node inside the drag and drop toolbar.
+ * These nodes require an onDrop function that dictates
+ * how the node is created in the graph.
  */
-function DraggableNode({className, children, nodeType, onDrop}: DraggableNodeProps) {
+function DraggableNode({ className, children, nodeType, onDrop }: DraggableNodeProps) {
   const draggableRef = useRef<HTMLDivElement>(null);
-  const [position, setPosition] = useState<XYPosition>({x: 0, y: 0});
+  const [position, setPosition] = useState<XYPosition>({ x: 0, y: 0 });
 
-  // @ts-expect-error comes from a package and doesn't appear to play nicely with strict typescript typing
+  // @ts-expect-error from the neodrag package — safe to ignore
   useDraggable(draggableRef, {
-    position: position,
-    onDrag: ({offsetX, offsetY}) => {
-      // Calculate position relative to the viewport
-      setPosition({
-        x: offsetX,
-        y: offsetY,
-      });
+    position,
+    onDrag: ({ offsetX, offsetY }) => {
+      setPosition({ x: offsetX, y: offsetY });
     },
-    onDragEnd: ({event}) => {
-      setPosition({x: 0, y: 0});
-      onDrop(nodeType, {
-        x: event.clientX,
-        y: event.clientY,
-      });
+    onDragEnd: ({ event }) => {
+      setPosition({ x: 0, y: 0 });
+      onDrop(nodeType, { x: event.clientX, y: event.clientY });
     },
   });
 
@@ -66,71 +43,48 @@ function DraggableNode({className, children, nodeType, onDrop}: DraggableNodePro
   );
 }
 
+/**
+ * addNode — adds a new node to the flow using the unified class-based system.
+ * Keeps numbering logic for phase/norm nodes.
+ */
+function addNode(nodeType: keyof typeof NodeTypes, position: XYPosition) {
+  const { nodes, setNodes } = useFlowStore.getState();
 
-// eslint-disable-next-line react-refresh/only-export-components
-export function addNode(nodeType: string, position: XYPosition) {
-  const {setNodes} = useFlowStore.getState();
-  const nds : AppNode[] = useFlowStore.getState().nodes;
-  const newNode = () => {
-    switch (nodeType) {
-      case "phase":
-      {
-        const phaseNodes= nds.filter((node) => node.type === 'phase');
-        let phaseNumber;
-        if (phaseNodes.length > 0) {
-          const finalPhaseId : number = +(phaseNodes[phaseNodes.length - 1].id.split('-')[1]);
-          phaseNumber = finalPhaseId + 1;
-        } else {
-          phaseNumber = 1;
-        }
-        const phaseNode : PhaseNode = {
-          id: `phase-${phaseNumber}`,
-          type: nodeType,
-          position,
-          data: {label: 'new', number: phaseNumber},
-        }
-        return phaseNode;
-      }
-      case "norm":
-      {
-        const normNodes= nds.filter((node) => node.type === 'norm');
-        let normNumber
-        if (normNodes.length > 0) {
-          const finalNormId : number = +(normNodes[normNodes.length - 1].id.split('-')[1]);
-          normNumber = finalNormId + 1;
-        } else {
-          normNumber = 1;
-        }
-
-        const normNode : NormNode = {
-          id: `norm-${normNumber}`,
-          type: nodeType,
-          position,
-          data: {label: `new norm node`, value: "Pepper should be formal"},
-        }
-        return normNode;
-      }
-      default: {
-        throw new Error(`Node ${nodeType} not found`);
-      }
-    }
+  // Find out if there's any default data about our ndoe
+  const defaultData = NodeDefaults[nodeType] ?? {}
+  
+  // Currently, we find out what the Id is by checking the last node and adding one
+  const sameTypeNodes = nodes.filter((node) => node.type === nodeType);
+  const nextNumber =
+    sameTypeNodes.length > 0
+      ? (() => {
+          const lastNode = sameTypeNodes[sameTypeNodes.length - 1];
+          const parts = lastNode.id.split('-');
+          const lastNum = Number(parts[1]);
+          return Number.isNaN(lastNum) ? sameTypeNodes.length + 1 : lastNum + 1;
+        })()
+      : 1;
+  const id = `${nodeType}-${nextNumber}`;
+  
+  // Create new node
+  const newNode = {
+    id: id,
+    type: nodeType,
+    position,
+    data: {...defaultData}
   }
-
-  setNodes(nds.concat(newNode()));
+  setNodes([...nodes, newNode]);
 }
 
 /**
- * the DndToolbar defines how the drag and drop toolbar component works
- * and includes the default onDrop behavior through handleNodeDrop
- * @constructor
+ * DndToolbar defines how the drag and drop toolbar component works
+ * and includes the default onDrop behavior.
  */
 export function DndToolbar() {
-  const {screenToFlowPosition} = useReactFlow();
-  /**
-   * handleNodeDrop implements the default onDrop behavior
-   */
+  const { screenToFlowPosition } = useReactFlow();
+
   const handleNodeDrop = useCallback(
-    (nodeType: string, screenPosition: XYPosition) => {
+    (nodeType: keyof typeof NodeTypes, screenPosition: XYPosition) => {
       const flow = document.querySelector('.react-flow');
       const flowRect = flow?.getBoundingClientRect();
       const isInFlow =
@@ -140,7 +94,6 @@ export function DndToolbar() {
         screenPosition.y >= flowRect.top &&
         screenPosition.y <= flowRect.bottom;
 
-      // Create a new node and add it to the flow
       if (isInFlow) {
         const position = screenToFlowPosition(screenPosition);
         addNode(nodeType, position);
@@ -149,24 +102,32 @@ export function DndToolbar() {
     [screenToFlowPosition],
   );
 
+
+  // Map over our default settings to see which of them have their droppable data set to true
+  const droppableNodes = Object.entries(NodeDefaults)
+  .filter(([, data]) => data.droppable)
+  .map(([type, data]) => ({ 
+    type: type as DraggableNodeProps['nodeType'], 
+    data 
+  }));
+
   return (
-    <div>
-
-      <div className={`flex-col gap-lg padding-md ${styles.innerDndPanel}`}>
-        <div className="description">
-          You can drag these nodes to the pane to create new nodes.
-        </div>
-        <div className={`flex-row gap-lg ${styles.dndNodeContainer}`}>
-          <DraggableNode className={styles.draggableNodePhase} nodeType="phase" onDrop={handleNodeDrop}>
-            phase Node
-          </DraggableNode>
-          <DraggableNode className={styles.draggableNodeNorm} nodeType="norm" onDrop={handleNodeDrop}>
-            norm Node
-          </DraggableNode>
-        </div>
+    <div className={`flex-col gap-lg padding-md ${styles.innerDndPanel}`}>
+      <div className="description">
+        You can drag these nodes to the pane to create new nodes.
+      </div>
+      <div className={`flex-row gap-lg ${styles.dndNodeContainer}`}>
+        {/* Maps over all the nodes that are droppable, and puts them in the panel */}
+        {droppableNodes.map(({type, data}) => (
+          <DraggableNode
+            className={styles[`draggable-node-${type}`]} // Our current style signature for nodes
+            nodeType={type}
+            onDrop={handleNodeDrop}
+          >
+            {data.label}
+          </DraggableNode>
+        ))}
       </div>
-
-      
     </div>
   );
-}
+}

src/pages/VisProgPage/visualProgrammingUI/components/NodeComponents.tsx

@@ -0,0 +1,32 @@
+import { NodeToolbar } from '@xyflow/react';
+import '@xyflow/react/dist/style.css';
+import useFlowStore from "../VisProgStores.tsx";
+
+//Toolbar definitions
+type ToolbarProps = {
+  nodeId: string;
+  allowDelete: boolean;
+};
+
+/**
+ * Node Toolbar definition:
+ * handles: node deleting functionality
+ * can be added to any custom node component as a React component
+ *
+ * @param {string} nodeId
+ * @param {boolean} allowDelete
+ * @returns {React.JSX.Element}
+ * @constructor
+ */
+export function Toolbar({nodeId, allowDelete}: ToolbarProps) {
+  const {deleteNode} = useFlowStore();
+
+  const deleteParentNode = ()=> {
+    deleteNode(nodeId);
+  }
+  return (
+    <NodeToolbar>
+      <button className="Node-toolbar__deletebutton" onClick={deleteParentNode} disabled={!allowDelete}>delete</button>
+    </NodeToolbar>);
+}
+

src/pages/VisProgPage/visualProgrammingUI/components/NodeDefinitions.tsx

@@ -1,183 +0,0 @@
-import {
-  Handle,
-  type NodeProps,
-  NodeToolbar,
-  Position
-} from '@xyflow/react';
-import '@xyflow/react/dist/style.css';
-import styles from '../../VisProg.module.css';
-import useFlowStore from "../VisProgStores.tsx";
-import type {
-  StartNode,
-  EndNode,
-  PhaseNode,
-  NormNode
-} from "../VisProgTypes.tsx";
-
-//Toolbar definitions
-
-type ToolbarProps = {
-  nodeId: string;
-  allowDelete: boolean;
-};
-
-
-/**
- * Node Toolbar definition:
- * handles: node deleting functionality
- * can be added to any custom node component as a React component
- *
- * @param {string} nodeId
- * @param {boolean} allowDelete
- * @returns {React.JSX.Element}
- * @constructor
- */
-export function Toolbar({nodeId, allowDelete}: ToolbarProps) {
-  const {deleteNode} = useFlowStore();
-
-  const deleteParentNode = ()=> {
-    deleteNode(nodeId);
-  }
-  return (
-    <NodeToolbar>
-      <button className="Node-toolbar__deletebutton" onClick={deleteParentNode} disabled={!allowDelete}>delete</button>
-    </NodeToolbar>);
-}
-
-// Renaming component
-
-/**
- * Adds a component that can be used to edit a node's label entry inside its Data
- * can be added to any custom node that has a label inside its Data
- *
- * @param {string} nodeLabel
- * @param {string} nodeId
- * @returns {React.JSX.Element}
- * @constructor
- */
-export function EditableName({nodeLabel = "new node", nodeId} : { nodeLabel : string, nodeId: string}) {
-  const {updateNodeData} = useFlowStore();
-
-  const updateData  = (event: React.FocusEvent<HTMLInputElement>) => {
-    const input = event.target.value;
-    updateNodeData(nodeId, {label: input});
-    event.currentTarget.setAttribute("readOnly", "true");
-    window.getSelection()?.empty();
-    event.currentTarget.classList.replace("nodrag", "drag"); // enable dragging of the node with cursor on the input box
-  };
-
-  const updateOnEnter = (event: React.KeyboardEvent<HTMLInputElement>) => { if (event.key === "Enter") (event.target as HTMLInputElement).blur(); };
-
-  const enableEditing = (event: React.MouseEvent<HTMLInputElement>) => {
-    if(event.currentTarget.hasAttribute("readOnly")) {
-      event.currentTarget.removeAttribute("readOnly"); // enable editing
-      event.currentTarget.select(); // select the text input
-      window.getSelection()?.collapseToEnd(); // move the caret to the end of the current value
-      event.currentTarget.classList.replace("drag", "nodrag"); // disable dragging using input box
-    }
-  }
-
-  return (
-    <div className={styles.NodeTextBar }>
-      <label>name: </label>
-      <input
-        className={`drag ${styles.nodeTextInput}`} // prevents dragging the component when user has focused the text input
-        type={"text"}
-        defaultValue={nodeLabel}
-        onKeyDown={updateOnEnter}
-        onBlur={updateData}
-        onClick={enableEditing}
-        maxLength={25}
-        readOnly
-      />
-    </div>
-  )
-}
-
-
-// Definitions of Nodes
-
-/**
- * Start Node definition:
- *
- * @param {string} id
- * @param {defaultNodeData} data
- * @returns {React.JSX.Element}
- * @constructor
- */
-export const StartNodeComponent = ({id, data}: NodeProps<StartNode>) => {
-  return (
-    <>
-      <Toolbar nodeId={id} allowDelete={false}/>
-      <div className={`${styles.defaultNode} ${styles.nodeStart}`}>
-        <div> data test {data.label} </div>
-        <Handle type="source" position={Position.Right} id="start"/>
-      </div>
-    </>
-  );
-};
-
-
-/**
- * End node definition:
- *
- * @param {string} id
- * @param {defaultNodeData} data
- * @returns {React.JSX.Element}
- * @constructor
- */
-export const EndNodeComponent = ({id, data}: NodeProps<EndNode>) => {
-  return (
-    <>
-      <Toolbar nodeId={id} allowDelete={false}/>
-      <div className={`${styles.defaultNode} ${styles.nodeEnd}`}>
-        <div> {data.label} </div>
-        <Handle type="target" position={Position.Left} id="end"/>
-      </div>
-    </>
-  );
-};
-
-
-/**
- * Phase node definition:
- *
- * @param {string} id
- * @param {defaultNodeData & {number: number}} data
- * @returns {React.JSX.Element}
- * @constructor
- */
-export const PhaseNodeComponent = ({id, data}: NodeProps<PhaseNode>) => {
-  return (
-    <>
-      <Toolbar nodeId={id} allowDelete={true}/>
-      <div className={`${styles.defaultNode} ${styles.nodePhase}`}>
-        <EditableName nodeLabel={data.label} nodeId={id}/>
-        <Handle type="target" position={Position.Left} id="target"/>
-        <Handle type="target" position={Position.Bottom} id="norms"/>
-        <Handle type="source" position={Position.Right} id="source"/>
-      </div>
-    </>
-  );
-};
-
-
-/**
- * Norm node definition:
- *
- * @param {string} id
- * @param {defaultNodeData & {value: string}} data
- * @returns {React.JSX.Element}
- * @constructor
- */
-export const NormNodeComponent = ({id, data}: NodeProps<NormNode>) => {
-  return (
-    <>
-      <Toolbar nodeId={id} allowDelete={true}/>
-      <div className={`${styles.defaultNode} ${styles.nodeNorm}`}>
-        <EditableName nodeLabel={data.label} nodeId={id}/>
-        <Handle type="source" position={Position.Right} id="NormSource"/>
-      </div>
-    </>
-  );
-};

src/pages/VisProgPage/visualProgrammingUI/nodes/EndNode.default.ts

@@ -0,0 +1,10 @@
+import type { EndNodeData } from "./EndNode";
+
+/**
+ * Default data for this node.
+ */
+export const EndNodeDefaults: EndNodeData = {
+  label: "End Node",
+  droppable: false,
+  hasReduce: true
+};

src/pages/VisProgPage/visualProgrammingUI/nodes/EndNode.tsx

@@ -0,0 +1,67 @@
+import {
+  Handle,
+  type NodeProps,
+  Position,
+  type Node,
+} from '@xyflow/react';
+import { Toolbar } from '../components/NodeComponents';
+import styles from '../../VisProg.module.css'; 
+
+/**
+ * The typing of this node's data
+ */
+export type EndNodeData = {
+  label: string;
+  droppable: boolean;
+  hasReduce: boolean;
+};
+
+export type EndNode = Node<EndNodeData>
+
+/**
+ * Default function to render an end node given its properties
+ * @param props the node's properties
+ * @returns React.JSX.Element
+ */
+export default function EndNode(props: NodeProps<EndNode>) {
+  return (
+    <>
+      <Toolbar nodeId={props.id} allowDelete={false}/>
+      <div className={`${styles.defaultNode} ${styles.nodeEnd}`}>
+        <div className={"flex-row gap-sm"}>
+        End
+        </div>
+        <Handle type="target" position={Position.Left} id="target"/>
+      </div>
+    </>
+  );
+}
+
+/**
+ * Functionality for reducing this node into its more compact json program
+ * @param node the node to reduce
+ * @param nodes all nodes present
+ * @returns Dictionary, {id: node.id}
+ */
+export function EndReduce(node: Node, nodes: Node[]) {
+  // Replace this for nodes functionality
+  if (nodes.length <= -1) { 
+    console.warn("Impossible nodes length in EndReduce") 
+  } 
+  return {
+    id: node.id
+  }
+}
+
+/**
+ * Any connection functionality that should get called when a connection is made to this node type (end)
+ * @param thisNode the node of which the functionality gets called
+ * @param otherNode the other node which has connected
+ * @param isThisSource whether this node is the one that is the source of the connection
+ */
+export function EndConnects(thisNode: Node, otherNode: Node, isThisSource: boolean) {
+  // Replace this for connection logic
+  if (thisNode == undefined && otherNode == undefined && isThisSource == false) { 
+    console.warn("Impossible node connection called in EndConnects")
+  }
+}

src/pages/VisProgPage/visualProgrammingUI/nodes/GoalNode.default.ts

@@ -0,0 +1,12 @@
+import type { GoalNodeData } from "./GoalNode";
+
+/**
+ * Default data for this node
+ */
+export const GoalNodeDefaults: GoalNodeData = {
+  label: "Goal Node",
+  droppable: true,
+  description: "The robot will strive towards this goal",
+  achieved: false,
+  hasReduce: true,
+};

src/pages/VisProgPage/visualProgrammingUI/nodes/GoalNode.tsx

@@ -0,0 +1,101 @@
+import {
+  Handle,
+  type NodeProps,
+  Position,
+  type Node,
+} from '@xyflow/react';
+import { Toolbar } from '../components/NodeComponents';
+import styles from '../../VisProg.module.css';
+import { TextField } from '../../../../components/TextField';
+import useFlowStore from '../VisProgStores';
+
+/**
+ * The default data dot a phase node
+ * @param label: the label of this phase
+ * @param droppable: whether this node is droppable from the drop bar (initialized as true)
+ * @param desciption: description of the goal
+ * @param hasReduce: whether this node has reducing functionality (true by default)
+ */
+export type GoalNodeData = {
+  label: string;
+  description: string;
+  droppable: boolean;
+  achieved: boolean;
+  hasReduce: boolean;
+};
+
+export type GoalNode = Node<GoalNodeData>
+
+
+/**
+ * Defines how a Goal node should be rendered
+ * @param props NodeProps, like id, label, children
+ * @returns React.JSX.Element
+ */
+export default function GoalNode(props: NodeProps<GoalNode>) {
+  const data = props.data
+  const {updateNodeData} = useFlowStore();
+
+  const text_input_id = `goal_${props.id}_text_input`;
+  const checkbox_id = `goal_${props.id}_checkbox`;
+
+  const setDescription = (value: string) => {
+    updateNodeData(props.id, {...data, description: value});
+  }
+
+  const setAchieved = (value: boolean) => {
+    updateNodeData(props.id, {...data, achieved: value});
+  }
+
+  return <>
+    <Toolbar nodeId={props.id} allowDelete={true}/>
+    <div className={`${styles.defaultNode} ${styles.nodeGoal} flex-col gap-sm`}>
+      <div className={"flex-row gap-md"}>
+        <label htmlFor={text_input_id}>Goal:</label>
+        <TextField
+          id={text_input_id}
+          value={data.description}
+          setValue={(val) => setDescription(val)}
+          placeholder={"To ..."}
+        />
+      </div>
+      <div className={"flex-row gap-md align-center"}>
+        <label htmlFor={checkbox_id}>Achieved:</label>
+        <input
+          id={checkbox_id}
+          type={"checkbox"}
+          value={data.achieved ? "checked" : ""}
+          onChange={(e) => setAchieved(e.target.checked)}
+        />
+      </div>
+      <Handle type="source" position={Position.Right} id="GoalSource"/>
+    </div>
+  </>;
+}
+
+
+/**
+ * Reduces each Goal, including its children down into its relevant data.
+ * @param node: The Node Properties of this node.
+ * @param nodes: all the nodes in the graph
+ */
+export function GoalReduce(node: Node, nodes: Node[]) {
+  // Replace this for nodes functionality
+  if (nodes.length <= -1) { 
+    console.warn("Impossible nodes length in GoalReduce") 
+  } 
+  const data = node.data as GoalNodeData;
+    return {
+      id: node.id,
+      label: data.label,
+      description: data.description,
+      achieved: data.achieved,
+    }
+}
+
+export function GoalConnects(thisNode: Node, otherNode: Node, isThisSource: boolean) {
+  // Replace this for connection logic
+  if (thisNode == undefined && otherNode == undefined && isThisSource == false) { 
+    console.warn("Impossible node connection called in EndConnects")
+  }
+}

src/pages/VisProgPage/visualProgrammingUI/nodes/NormNode.default.ts

@@ -0,0 +1,11 @@
+import type { NormNodeData } from "./NormNode";
+
+/**
+ * Default data for this node
+ */
+export const NormNodeDefaults: NormNodeData = {
+  label: "Norm Node",
+  droppable: true,
+  norm: "",
+  hasReduce: true,
+};

src/pages/VisProgPage/visualProgrammingUI/nodes/NormNode.tsx

@@ -0,0 +1,84 @@
+import {
+  Handle,
+  type NodeProps,
+  Position,
+  type Node,
+} from '@xyflow/react';
+import { Toolbar } from '../components/NodeComponents';
+import styles from '../../VisProg.module.css';
+import { TextField } from '../../../../components/TextField';
+import useFlowStore from '../VisProgStores';
+
+/**
+ * The default data dot a phase node
+ * @param label: the label of this phase
+ * @param droppable: whether this node is droppable from the drop bar (initialized as true)
+ * @param norm: list of strings of norms for this node
+ * @param hasReduce: whether this node has reducing functionality (true by default)
+ */
+export type NormNodeData = {
+  label: string;
+  droppable: boolean;
+  norm: string;
+  hasReduce: boolean;
+};
+
+export type NormNode = Node<NormNodeData>
+
+/**
+ * Defines how a Norm node should be rendered
+ * @param props NodeProps, like id, label, children
+ * @returns React.JSX.Element
+ */
+export default function NormNode(props: NodeProps<NormNode>) {
+  const data = props.data;
+  const {updateNodeData} = useFlowStore();
+
+  const text_input_id = `norm_${props.id}_text_input`;
+
+  const setValue = (value: string) => {
+    updateNodeData(props.id, {norm: value});
+  }
+
+  return <>
+    <Toolbar nodeId={props.id} allowDelete={true}/>
+    <div className={`${styles.defaultNode} ${styles.nodeNorm}`}>
+      <div className={"flex-row gap-sm"}>
+        <label htmlFor={text_input_id}>Norm :</label>
+        <TextField
+          id={text_input_id}
+          value={data.norm}
+          setValue={(val) => setValue(val)}
+          placeholder={"Pepper should ..."}
+        />
+      </div>
+      <Handle type="source" position={Position.Right} id="norms"/>
+    </div>
+  </>;
+};
+
+
+/**
+ * Reduces each Norm, including its children down into its relevant data.
+ * @param node: The Node Properties of this node.
+ * @param nodes: all the nodes in the graph
+ */
+export function NormReduce(node: Node, nodes: Node[]) {
+  // Replace this for nodes functionality
+  if (nodes.length <= -1) { 
+    console.warn("Impossible nodes length in NormReduce") 
+  } 
+  const data = node.data as NormNodeData;
+    return {
+      id: node.id,
+      label: data.label,
+      norm: data.norm,
+    }
+}
+
+export function NormConnects(thisNode: Node, otherNode: Node, isThisSource: boolean) {
+  // Replace this for connection logic
+  if (thisNode == undefined && otherNode == undefined && isThisSource == false) { 
+    console.warn("Impossible node connection called in EndConnects")
+  }
+}

src/pages/VisProgPage/visualProgrammingUI/nodes/PhaseNode.default.ts

@@ -0,0 +1,11 @@
+import type { PhaseNodeData } from "./PhaseNode";
+
+/**
+ * Default data for this node
+ */
+export const PhaseNodeDefaults: PhaseNodeData = {
+  label: "Phase Node",
+  droppable: true,
+  children: [],
+  hasReduce: true,
+};

src/pages/VisProgPage/visualProgrammingUI/nodes/PhaseNode.tsx

@@ -0,0 +1,116 @@
+import {
+  Handle,
+  type NodeProps,
+  Position,
+  type Node,
+} from '@xyflow/react';
+import { Toolbar } from '../components/NodeComponents';
+import styles from '../../VisProg.module.css';
+import { NodeReduces, NodesInPhase, NodeTypes } from '../NodeRegistry';
+import useFlowStore from '../VisProgStores';
+import { TextField } from '../../../../components/TextField';
+
+/**
+ * The default data dot a phase node
+ * @param label: the label of this phase
+ * @param droppable: whether this node is droppable from the drop bar (initialized as true)
+ * @param children: ID's of children of this node
+ * @param hasReduce: whether this node has reducing functionality (true by default)
+ */
+export type PhaseNodeData = {
+  label: string;
+  droppable: boolean;
+  children: string[];
+  hasReduce: boolean;
+};
+
+export type PhaseNode = Node<PhaseNodeData>
+
+/**
+ * Defines how a phase node should be rendered
+ * @param props NodeProps, like id, label, children
+ * @returns React.JSX.Element
+ */
+export default function PhaseNode(props: NodeProps<PhaseNode>) {
+  const data = props.data;
+  const {updateNodeData} = useFlowStore();
+  const updateLabel = (value: string) => updateNodeData(props.id, {...data, label: value});
+  const label_input_id = `phase_${props.id}_label_input`;
+
+  return (
+    <>
+      <Toolbar nodeId={props.id} allowDelete={true}/>
+      <div className={`${styles.defaultNode} ${styles.nodePhase}`}>
+        <div className={"flex-row gap-sm"}>
+          <label htmlFor={label_input_id}>Name:</label>
+          <TextField
+            id={label_input_id}
+            value={data.label}
+            setValue={updateLabel}
+            placeholder={"Phase ..."}
+          />
+        </div>
+        <Handle type="target" position={Position.Left} id="target"/>
+        <Handle type="target" position={Position.Bottom} id="norms"/>
+        <Handle type="source" position={Position.Right} id="source"/>
+      </div>
+    </>
+  );
+};
+
+/**
+ * Reduces each phase, including its children down into its relevant data.
+ * @param node the node which is being reduced
+ * @param nodes all the nodes currently in the flow.
+ * @returns A collection of all reduced nodes in this phase, starting with this phases' reduced data.  
+ */
+export function PhaseReduce(node: Node, nodes: Node[]) {
+    const thisnode = node as PhaseNode;
+    const data = thisnode.data as PhaseNodeData;
+
+    // node typings that are not in phase
+    const nodesNotInPhase: string[] = Object.entries(NodesInPhase)
+        .filter(([, f]) => !f())
+        .map(([t]) => t);
+
+    // node typings that then are in phase
+    const nodesInPhase: string[] = Object.entries(NodeTypes)
+        .filter(([t]) => !nodesNotInPhase.includes(t))
+        .map(([t]) => t);
+
+    // children nodes
+    const childrenNodes = nodes.filter((node) => data.children.includes(node.id));
+
+    // Build the result object
+    const result: Record<string, unknown> = {
+        id: thisnode.id,
+        label: data.label,
+    };
+
+    nodesInPhase.forEach((type) => {
+        const typedChildren = childrenNodes.filter((child) => child.type == type);
+        const reducer = NodeReduces[type as keyof typeof NodeReduces];
+        if (!reducer) {
+            console.warn(`No reducer found for node type ${type}`);
+            result[type + "s"] = [];
+        } else {
+            result[type + "s"] = typedChildren.map((child) => reducer(child, nodes));
+        }
+    });
+
+    return result;
+}
+
+/**
+ * This function is called whenever a connection is made with this node type (phase)
+ * @param thisNode the node of this node type which function is called
+ * @param otherNode the other node which was part of the connection
+ * @param isThisSource whether this instance of the node was the source in the connection, true = yes.
+ */
+export function PhaseConnects(thisNode: Node, otherNode: Node, isThisSource: boolean) {
+  console.log("Connect functionality called.")
+  const node = thisNode as PhaseNode
+  const data = node.data as PhaseNodeData
+  if (!isThisSource)
+    data.children.push(otherNode.id)
+}

src/pages/VisProgPage/visualProgrammingUI/nodes/StartNode.default.ts

@@ -0,0 +1,10 @@
+import type { StartNodeData } from "./StartNode";
+
+/**
+ * Default data for this node.
+ */
+export const StartNodeDefaults: StartNodeData = {
+  label: "Start Node",
+  droppable: false,
+  hasReduce: true
+};

src/pages/VisProgPage/visualProgrammingUI/nodes/StartNode.tsx

@@ -0,0 +1,67 @@
+import {
+  Handle,
+  type NodeProps,
+  Position,
+  type Node,
+} from '@xyflow/react';
+import { Toolbar } from '../components/NodeComponents';
+import styles from '../../VisProg.module.css';
+
+
+export type StartNodeData = {
+  label: string;
+  droppable: boolean;
+  hasReduce: boolean;
+};
+
+
+export type StartNode = Node<StartNodeData>
+
+
+/**
+ * Defines how a Norm node should be rendered
+ * @param props NodeProps, like id, label, children
+ * @returns React.JSX.Element
+ */
+export default function StartNode(props: NodeProps<StartNode>) {
+  return (
+    <>
+      <Toolbar nodeId={props.id} allowDelete={false}/>
+      <div className={`${styles.defaultNode} ${styles.nodeStart}`}>
+        <div className={"flex-row gap-sm"}>
+          Start
+        </div>
+        <Handle type="source" position={Position.Right} id="source"/>
+      </div>
+    </>
+  );
+}
+
+/**
+ * The reduce function for this node type.
+ * @param node this node
+ * @param nodes all the nodes in the graph
+ * @returns a reduced structure of this node
+ */
+export function StartReduce(node: Node, nodes: Node[]) {
+  // Replace this for nodes functionality
+  if (nodes.length <= -1) { 
+    console.warn("Impossible nodes length in StartReduce") 
+  } 
+  return {
+    id: node.id
+  }
+}
+
+/**
+ * This function is called whenever a connection is made with this node type (start)
+ * @param thisNode the node of this node type which function is called
+ * @param otherNode the other node which was part of the connection
+ * @param isThisSource whether this instance of the node was the source in the connection, true = yes.
+ */
+export function StartConnects(thisNode: Node, otherNode: Node, isThisSource: boolean) {
+  // Replace this for connection logic
+  if (thisNode == undefined && otherNode == undefined && isThisSource == false) { 
+    console.warn("Impossible node connection called in EndConnects")
+  }
+}

src/pages/VisProgPage/visualProgrammingUI/nodes/TriggerNode.default.ts

@@ -0,0 +1,12 @@
+import type { TriggerNodeData } from "./TriggerNode";
+
+/**
+ * Default data for this node
+ */
+export const TriggerNodeDefaults: TriggerNodeData = {
+  label: "Trigger Node",
+  droppable: true,
+  triggers: [],
+  triggerType: "keywords",
+  hasReduce: true,
+};

src/pages/VisProgPage/visualProgrammingUI/nodes/TriggerNode.tsx

@@ -0,0 +1,187 @@
+import {
+  Handle,
+  type NodeProps,
+  Position,
+  type Connection,
+  type Edge,
+  type Node,
+} from '@xyflow/react';
+import { Toolbar } from '../components/NodeComponents';
+import styles from '../../VisProg.module.css';
+import useFlowStore from '../VisProgStores';
+import { useState } from 'react';
+import { RealtimeTextField, TextField } from '../../../../components/TextField';
+import duplicateIndices from '../../../../utils/duplicateIndices';
+
+/**
+ * The default data dot a Trigger node
+ * @param label: the label of this Trigger
+ * @param droppable: whether this node is droppable from the drop bar (initialized as true)
+ * @param children: ID's of children of this node
+ */
+export type TriggerNodeData = {
+  label: string;
+  droppable: boolean;
+  triggerType: "keywords" | string;
+  triggers: Keyword[] | never;
+  hasReduce: boolean;
+};
+
+
+export type TriggerNode = Node<TriggerNodeData>
+
+
+export function TriggerNodeCanConnect(connection: Connection | Edge): boolean {
+  return (connection != undefined);
+}
+
+/**
+ * Defines how a Trigger node should be rendered
+ * @param props NodeProps, like id, label, children
+ * @returns React.JSX.Element
+ */
+export default function TriggerNode(props: NodeProps<TriggerNode>) {
+  const data = props.data;
+  const {updateNodeData} = useFlowStore();
+
+  const setKeywords = (keywords: Keyword[]) => {
+    updateNodeData(props.id, {...data, triggers: keywords});
+  }
+
+  return <>
+    <Toolbar nodeId={props.id} allowDelete={true}/>
+    <div className={`${styles.defaultNode} ${styles.nodeTrigger} flex-col gap-sm`}>
+      {data.triggerType === "emotion" && (
+        <div className={"flex-row gap-md"}>Emotion?</div>
+      )}
+      {data.triggerType === "keywords" && (
+        <Keywords
+          keywords={data.triggers}
+          setKeywords={setKeywords}
+        />
+      )}
+      <Handle type="source" position={Position.Right} id="TriggerSource"/>
+    </div>
+  </>;
+}
+
+/**
+ * Reduces each Trigger, including its children down into its relevant data.
+ * @param node: The Node Properties of this node.
+ * @param nodes: all the nodes in the graph.
+ */
+export function TriggerReduce(node: Node, nodes: Node[]) {
+  // Replace this for nodes functionality
+  if (nodes.length <= -1) { 
+    console.warn("Impossible nodes length in TriggerReduce") 
+  } 
+  const data = node.data as TriggerNodeData;
+    return {
+      label: data.label,
+      list: data.triggers,
+    }
+}
+
+/**
+ * This function is called whenever a connection is made with this node type (trigger)
+ * @param thisNode the node of this node type which function is called
+ * @param otherNode the other node which was part of the connection
+ * @param isThisSource whether this instance of the node was the source in the connection, true = yes.
+ */
+export function TriggerConnects(thisNode: Node, otherNode: Node, isThisSource: boolean) {
+  // Replace this for connection logic
+  if (thisNode == undefined && otherNode == undefined && isThisSource == false) { 
+    console.warn("Impossible node connection called in EndConnects")
+  }
+}
+
+// Definitions for the possible triggers, being keywords and emotions
+type Keyword = { id: string, keyword: string };
+
+export type EmotionTriggerNodeProps = {
+  type: "emotion";
+  value: string;
+}
+export type KeywordTriggerNodeProps = {
+  type: "keywords";
+  value: Keyword[];
+}
+
+export type TriggerNodeProps = EmotionTriggerNodeProps | KeywordTriggerNodeProps;
+
+/**
+ * The JSX element that is responsible for updating the field and showing the text
+ * @param param0 the function that updates the field
+ * @returns React.JSX.Element that handles adding keywords
+ */
+function KeywordAdder({ addKeyword }: { addKeyword: (keyword: string) => void }) {
+  const [input, setInput] = useState("");
+
+  const text_input_id = "keyword_adder_input";
+
+  return <div className={"flex-row gap-md"}>
+    <label htmlFor={text_input_id}>New Keyword:</label>
+    <RealtimeTextField
+      id={text_input_id}
+      value={input}
+      setValue={setInput}
+      onCommit={() => {
+        if (!input) return;
+        addKeyword(input);
+        setInput("");
+      }}
+      placeholder={"..."}
+      className={"flex-1"}
+    />
+  </div>;
+}
+
+function Keywords({
+  keywords,
+  setKeywords,
+}: {
+  keywords: Keyword[];
+  setKeywords: (keywords: Keyword[]) => void;
+}) {
+  type Interpolatable = string | number | boolean | bigint | null | undefined;
+
+  const inputElementId = (id: Interpolatable) => `keyword_${id}_input`;
+
+  /** Indices of duplicates in the keyword array. */
+  const [duplicates, setDuplicates] = useState<number[]>([]);
+
+  function replace(id: string, value: string) {
+    value = value.trim();
+    const newKeywords = value === ""
+      ? keywords.filter((kw) => kw.id != id)
+      : keywords.map((kw) => kw.id === id ? {...kw, keyword: value} : kw);
+    setKeywords(newKeywords);
+    setDuplicates(duplicateIndices(newKeywords.map((kw) => kw.keyword)));
+  }
+
+  function add(value: string) {
+    value = value.trim();
+    if (value === "") return;
+    const newKeywords = [...keywords, {id: crypto.randomUUID(), keyword: value}];
+    setKeywords(newKeywords);
+    setDuplicates(duplicateIndices(newKeywords.map((kw) => kw.keyword)));
+  }
+
+  return <>
+    <span>Triggers when {keywords.length <= 1 ? "the keyword is" : "all keywords are"} spoken.</span>
+    {[...keywords].map(({id, keyword}, index) => {
+      return <div key={id} className={"flex-row gap-md"}>
+        <label htmlFor={inputElementId(id)}>Keyword:</label>
+        <TextField
+          id={inputElementId(id)}
+          value={keyword}
+          setValue={(val) => replace(id, val)}
+          placeholder={"..."}
+          className={"flex-1"}
+          invalid={duplicates.includes(index)}
+        />
+      </div>;
+    })}
+    <KeywordAdder addKeyword={add} />
+  </>;
+}