fix!: props and composable not merging together properly

* Add getter for node/edge types
* change nodeTypes prop type to only Record<string, NodeType> - same for edges
* Add rgb example
* remove v-model for elements

Signed-off-by: Braks <78412429+bcakmakoglu@users.noreply.github.com>

src/container/EdgeRenderer/EdgeRenderer.vue

@@ -1,13 +1,12 @@
 <script lang="ts" setup>
 import { CSSProperties } from 'vue'
-import { ConnectionLineType, EdgeType } from '../../types'
+import { ConnectionLineType, Edge as TEdge } from '../../types'
 import { useStore } from '../../composables'
 import Edge from '../../components/Edges/Edge.vue'
 import ConnectionLine from '../../components/ConnectionLine/ConnectionLine.vue'
 import MarkerDefinitions from './MarkerDefinitions.vue'
 
 interface EdgeRendererProps {
-  edgeTypes: Record<string, EdgeType>
   connectionLineType?: ConnectionLineType
   connectionLineStyle?: CSSProperties
   arrowHeadColor?: string
@@ -27,21 +26,23 @@ const sourceNode = computed(() => store.nodes.find((n) => n.id === store.connect
 const connectionLineVisible = computed(
   () => !!(store.nodesConnectable && sourceNode.value && store.connectionNodeId && store.connectionHandleType),
 )
-const edges = computed(() => store.edges.filter((edge) => !edge.isHidden))
 const dimensions = computed(() => store.dimensions)
 const transform = computed(() => `translate(${store.transform[0]},${store.transform[1]}) scale(${store.transform[2]})`)
+const type = (edge: TEdge) => {
+  const edgeType = edge.type || 'default'
+  const type = store.getEdgeTypes[edgeType] || store.getEdgeTypes.default
+  if (!store.getEdgeTypes[edgeType]) {
+    console.warn(`Edge type "${edgeType}" not found. Using fallback type "default".`)
+  }
+  return type
+}
 </script>
 <template>
   <svg :width="dimensions.width" :height="dimensions.height" class="vue-flow__edges">
     <MarkerDefinitions :color="props.arrowHeadColor" />
     <g :transform="transform">
-      <template v-for="edge of edges" :key="edge.id">
-        <Edge
-          :edge="edge"
-          :type="props.edgeTypes[edge.type || 'default']"
-          :marker-end-id="props.markerEndId"
-          :edge-updater-radius="props.edgeUpdaterRadius"
-        >
+      <template v-for="edge of store.getEdges" :key="edge.id">
+        <Edge :edge="edge" :type="type(edge)" :marker-end-id="props.markerEndId" :edge-updater-radius="props.edgeUpdaterRadius">
           <template #default="edgeProps">
             <slot :name="`edge-${edge.type}`" v-bind="edgeProps"></slot>
           </template>

src/container/NodeRenderer/NodeRenderer.vue

@@ -1,11 +1,9 @@
 <script lang="ts" setup>
-import { NodeType, Node as TNode } from '../../types'
+import { Node as TNode } from '../../types'
 import { useStore } from '../../composables'
 import Node from '../../components/Nodes/Node.vue'
-import { getNodesInside } from '~/utils'
 
 interface NodeRendererProps {
-  nodeTypes: Record<string, NodeType>
   selectNodesOnDrag?: boolean
 }
 
@@ -15,31 +13,13 @@ const props = withDefaults(defineProps<NodeRendererProps>(), {
 
 const store = useStore()
 
-const nodes = computed(() => {
-  const n = store.onlyRenderVisibleElements
-    ? store.nodes &&
-      getNodesInside(
-        store.nodes,
-        {
-          x: 0,
-          y: 0,
-          width: store.dimensions.width,
-          height: store.dimensions.height,
-        },
-        store.transform,
-        true,
-      )
-    : store.nodes
-
-  return n.filter((node) => !node.isHidden)
-})
 const transform = computed(() => `translate(${store.transform[0]}px,${store.transform[1]}px) scale(${store.transform[2]})`)
 const snapGrid = computed(() => (store.snapToGrid ? store.snapGrid : undefined))
 
 const type = (node: TNode) => {
   const nodeType = node.type || 'default'
-  const type = props.nodeTypes[nodeType] || props.nodeTypes.default
-  if (!props.nodeTypes[nodeType]) {
+  const type = store.getNodeTypes[nodeType] || store.getNodeTypes.default
+  if (!store.getNodeTypes[nodeType]) {
     console.warn(`Node type "${nodeType}" not found. Using fallback type "default".`)
   }
   return type
@@ -49,7 +29,7 @@ const selected = (nodeId: string) => store.selectedElements?.some(({ id }) => id
 <template>
   <div class="vue-flow__nodes" :style="{ transform }">
     <Suspense>
-      <template v-for="node of nodes" :key="node.id">
+      <template v-for="node of store.getNodes" :key="node.id">
         <Node
           :node="node"
           :type="type(node)"

src/container/VueFlow/VueFlow.vue

@@ -18,14 +18,12 @@ import ZoomPane from '../../container/ZoomPane/ZoomPane.vue'
 import SelectionPane from '../../container/SelectionPane/SelectionPane.vue'
 import NodeRenderer from '../../container/NodeRenderer/NodeRenderer.vue'
 import EdgeRenderer from '../../container/EdgeRenderer/EdgeRenderer.vue'
-import { DefaultNode, InputNode, OutputNode } from '../../components/Nodes'
-import { BezierEdge, SmoothStepEdge, StepEdge, StraightEdge } from '../../components/Edges'
 import { createHooks, initFlow } from '../../composables'
 
 export interface FlowProps extends FlowOptions {
   elements: Elements
-  nodeTypes?: Record<string, NodeType> | string[]
-  edgeTypes?: Record<string, EdgeType> | string[]
+  nodeTypes?: Record<string, NodeType>
+  edgeTypes?: Record<string, EdgeType>
   connectionMode?: ConnectionMode
   connectionLineType?: ConnectionLineType
   connectionLineStyle?: CSSProperties
@@ -58,7 +56,7 @@ export interface FlowProps extends FlowOptions {
   edgeUpdaterRadius?: number
   edgeTypesId?: string
   nodeTypesId?: string
-  storage?: string
+  storageKey?: string
 }
 
 const props = withDefaults(defineProps<FlowProps>(), {
@@ -103,30 +101,19 @@ const props = withDefaults(defineProps<FlowProps>(), {
 
 const emit = defineEmits(Object.keys(createHooks()))
 
-const defaultNodeTypes: Record<string, NodeType> = {
-  input: InputNode as NodeType,
-  default: DefaultNode as NodeType,
-  output: OutputNode as NodeType,
-}
-
-const defaultEdgeTypes: Record<string, EdgeType> = {
-  default: BezierEdge as EdgeType,
-  straight: StraightEdge as EdgeType,
-  step: StepEdge as EdgeType,
-  smoothstep: SmoothStepEdge as EdgeType,
-}
-
 const { store, hooks } = initFlow(emit, props)
-
 const init = (opts: typeof props) => {
-  store.$state = { ...store.$state, ...(props as any) }
+  store.elements = opts.elements
+  for (const opt of Object.keys(opts)) {
+    const val = opts[opt as keyof FlowProps]
+    if (val && typeof val !== 'undefined') (store.$state as any)[opt] = val
+  }
+  store.setElements(store.elements)
   store.setMinZoom(opts.minZoom)
   store.setMaxZoom(opts.maxZoom)
   store.setTranslateExtent(opts.translateExtent)
   store.setNodeExtent(opts.nodeExtent)
 }
-const elements = useVModel(props, 'elements', emit)
-
 onBeforeUnmount(() => store?.$dispose())
 
 watch(
@@ -141,32 +128,6 @@ invoke(async () => {
   await until(props.elements).toMatch((y) => y.length > 0)
   init(props)
 })
-
-watch(
-  elements,
-  (val, oldVal) => {
-    nextTick(() => {
-      const hasDiff = diff(val, oldVal)
-      if (hasDiff.length > 0) store.setElements(val)
-    })
-  },
-  { flush: 'post', deep: true },
-)
-
-const nodeTypes = computed(() => {
-  let types = defaultNodeTypes
-  if (Array.isArray(props.nodeTypes)) props.nodeTypes.forEach((type) => (types[type] = true))
-  else types = { ...types, ...props.nodeTypes }
-  store.$state.nodeTypes = types
-  return types
-})
-const edgeTypes = computed(() => {
-  let types = defaultEdgeTypes
-  if (Array.isArray(props.edgeTypes)) props.edgeTypes.forEach((type) => (types[type] = true))
-  else types = { ...types, ...props.edgeTypes }
-  store.$state.edgeTypes = types
-  return types
-})
 </script>
 <template>
   <div class="vue-flow">
@@ -190,8 +151,8 @@ const edgeTypes = computed(() => {
             :multi-selection-key-code="props.multiSelectionKeyCode"
             :selection-key-code="props.selectionKeyCode"
           >
-            <NodeRenderer :node-types="nodeTypes" :select-nodes-on-drag="props.selectNodesOnDrag">
-              <template v-for="nodeName of Object.keys(nodeTypes)" #[`node-${nodeName}`]="nodeProps">
+            <NodeRenderer :select-nodes-on-drag="props.selectNodesOnDrag">
+              <template v-for="nodeName of Object.keys(store.getNodeTypes)" #[`node-${nodeName}`]="nodeProps">
                 <slot :name="`node-${nodeName}`" v-bind="nodeProps"></slot>
               </template>
             </NodeRenderer>
@@ -200,9 +161,8 @@ const edgeTypes = computed(() => {
               :connection-line-style="props.connectionLineStyle"
               :arrow-head-color="props.arrowHeadColor"
               :marker-end-id="props.markerEndId"
-              :edge-types="edgeTypes"
             >
-              <template v-for="edgeName of Object.keys(edgeTypes)" #[`edge-${edgeName}`]="edgeProps">
+              <template v-for="edgeName of Object.keys(store.getEdgeTypes)" #[`edge-${edgeName}`]="edgeProps">
                 <slot :name="`edge-${edgeName}`" v-bind="edgeProps"></slot>
               </template>
               <template #custom-connection-line="customConnectionLineProps">