EXPLORATION 01 / 06

Basic canvas

What this showsA small, connective workflow you can move, wire, inspect, and reset. Start with the handles, then use the viewport tools to change your view.

inputIncoming event

A starting point

transformMake it useful

Clean & normalize

sinkShip the result

Ready for the next step

noteYour canvas, your rules

Drag a node. Follow a connection. Zoom out.

Svelte Flow

Live canvas 4 nodes · 2 edges

What this shows

Nodes remain draggable while handles create real edges. Use Shift to select a group, then pan, zoom, or fit the workflow with the built-in controls.

Nodes: 4
Edges: 2

Under the hood SVELTE 5View source

src/routes/demo/basic/+page.svelte

<script lang="ts">
  import { Background, BackgroundVariant, Controls, MiniMap, Panel, SvelteFlow } from '@xyflow/svelte';
  import type { Connection } from '@xyflow/svelte';
  import DemoShell from '$lib/components/DemoShell.svelte';
  import StudioNode from '$lib/components/StudioNode.svelte';
  import { createDemoGraph, createEdge, type FlowEdge, type FlowNode } from '$lib/flow/graph';
  import source from './+page.svelte?raw';


  const nodeTypes = {
    input: StudioNode,
    transform: StudioNode,
    branch: StudioNode,
    sink: StudioNode,
    note: StudioNode
  };

  const cloneGraph = () => {
    const graph = createDemoGraph('basic');
    return {
      nodes: graph.nodes.map((node) => ({
        ...node,
        position: { ...node.position },
        data: { ...node.data, params: { ...node.data.params } }
      })),
      edges: graph.edges.map((edge) => ({ ...edge, data: { ...edge.data } }))
    } satisfies { nodes: FlowNode[]; edges: FlowEdge[] };
  };

  const initialGraph = cloneGraph();
  let nodes = $state.raw<FlowNode[]>(initialGraph.nodes);
  let edges = $state.raw<FlowEdge[]>(initialGraph.edges);
  let edgeSerial = 0;

  let nodeCount = $derived(nodes.length);
  let edgeCount = $derived(edges.length);

  function resetGraph() {
    const graph = cloneGraph();
    nodes = graph.nodes;
    edges = graph.edges;
    edgeSerial = 0;
  }

  function onBeforeConnect(connection: Connection): FlowEdge | false {
    if (!connection.source || !connection.target) return false;

    edgeSerial += 1;
    return createEdge(
      `basic-connection-${edgeSerial}`,
      connection.source,
      connection.target,
      'data',
      {
        sourceHandle: connection.sourceHandle ?? null,
        targetHandle: connection.targetHandle ?? null
      }
    );
  }


  function minimapNodeColor(node: { type?: string }) {
    if (node.type === 'input') return 'var(--accent)';
    if (node.type === 'sink') return 'var(--ink)';
    if (node.type === 'branch') return 'var(--muted)';
    return 'var(--accent-soft)';
  }
</script>

<DemoShell
  slug="basic"
  title="Basic canvas"
  description="A small, connective workflow you can move, wire, inspect, and reset. Start with the handles, then use the viewport tools to change your view."
  {source}
>
  {#snippet toolbar()}
    <div class="toolbar-group" aria-label="Basic canvas actions">
      <button class="btn btn-sm btn-outline" type="button" onclick={resetGraph}>
        <span aria-hidden="true">↺</span>
        Reset canvas
      </button>
      <span class="toolbar-hint">Drag a handle to connect nodes</span>
    </div>
  {/snippet}

  {#snippet info()}
    <div class="info-layout">
      <div>
        <p class="eyebrow">What this shows</p>
        <p class="info-copy">
          Nodes remain draggable while handles create real edges. Use <kbd>Shift</kbd> to select a
          group, then pan, zoom, or fit the workflow with the built-in controls.
        </p>
      </div>
      <dl class="metric-list" aria-label="Live graph counts">
        <div>
          <dt>Nodes</dt>
          <dd>{nodeCount}</dd>
        </div>
        <div>
          <dt>Edges</dt>
          <dd>{edgeCount}</dd>
        </div>
      </dl>
    </div>
  {/snippet}

  <SvelteFlow
    id="demo-basic"
    bind:nodes
    bind:edges
    {nodeTypes}
    onbeforeconnect={onBeforeConnect}
    fitView
    fitViewOptions={{ padding: 0.2 }}
    nodesConnectable
    nodesDraggable
    aria-label="Basic workflow canvas"
  >
    <Background variant={BackgroundVariant.Dots} patternColor="var(--line)" gap={24} size={1.2} />
    <Controls />
    <MiniMap nodeColor={minimapNodeColor} pannable zoomable />
    <Panel position="bottom-left">
      <div class="canvas-status">
        <span class="status-dot" aria-hidden="true"></span>
        <span>Live canvas</span>
        <span class="status-divider" aria-hidden="true"></span>
        <span>{nodeCount} nodes · {edgeCount} edges</span>
      </div>
    </Panel>
  </SvelteFlow>
</DemoShell>

<style>
  .toolbar-group {
    display: flex;
    align-items: center;
    flex-wrap: wrap;
    gap: 0.625rem;
  }

  .toolbar-hint {
    color: var(--muted);
    font-size: 0.75rem;
    letter-spacing: 0.01em;
  }

  .info-layout {
    display: flex;
    align-items: flex-start;
    justify-content: space-between;
    gap: 1.5rem;
  }

  .info-copy {
    max-width: 46rem;
    margin: 0.35rem 0 0;
    color: var(--muted);
    font-size: 0.875rem;
    line-height: 1.6;
  }

  .eyebrow {
    margin: 0;
    color: var(--accent);
    font-size: 0.7rem;
    font-weight: 700;
    letter-spacing: 0.12em;
    text-transform: uppercase;
  }

  kbd {
    border: 1px solid var(--line);
    border-bottom-width: 2px;
    border-radius: 0.25rem;
    padding: 0.05rem 0.3rem;
    color: var(--ink);
    background: var(--surface-2);
    font-size: 0.72rem;
  }

  .metric-list {
    display: flex;
    flex: 0 0 auto;
    gap: 1.2rem;
    margin: 0;
  }

  .metric-list div {
    min-width: 3.2rem;
  }

  .metric-list dt {
    color: var(--muted);
    font-size: 0.7rem;
    letter-spacing: 0.08em;
    text-transform: uppercase;
  }

  .metric-list dd {
    margin: 0.15rem 0 0;
    color: var(--ink);
    font-size: 1.35rem;
    font-weight: 750;
    line-height: 1;
  }

  :global(.svelte-flow__panel) {
    margin: 0.85rem;
  }

  .canvas-status {
    display: flex;
    align-items: center;
    gap: 0.45rem;
    border: 1px solid var(--line);
    border-radius: 0.5rem;
    padding: 0.45rem 0.6rem;
    color: var(--muted);
    background: color-mix(in srgb, var(--surface) 94%, transparent);
    box-shadow: 0 0.35rem 1rem color-mix(in srgb, var(--ink) 8%, transparent);
    font-size: 0.7rem;
    white-space: nowrap;
  }

  .status-dot {
    width: 0.45rem;
    height: 0.45rem;
    border-radius: 999px;
    background: var(--accent);
  }

  .status-divider {
    width: 1px;
    height: 0.8rem;
    background: var(--line);
  }

  @media (max-width: 620px) {
    .info-layout {
      display: block;
    }

    .metric-list {
      margin-top: 0.9rem;
    }

    .toolbar-hint {
      flex-basis: 100%;
    }

    :global(.svelte-flow__panel) {
      margin: 0.55rem;
    }

    .canvas-status {
      font-size: 0.65rem;
    }
  }
</style>

The actual route source, imported with ?raw. Shared components and graph utilities live in src/lib.