Skip to content

TaskView is a self-hosted project and task management platform focused on clarity, ownership, and control. TaskView is built for teams that want a transparent, self-hosted alternative to SaaS task managers.

9.6 KB
Raw Blame
<template>
  <VueFlow
    v-if="canViewGraph"
    v-model:nodes="store.nodes"
    v-model:edges="store.edges"
    :min-zoom="-2"
    only-render-visible-elements
    elevate-edges-on-select
    elevate-nodes-on-select
    :pan-on-scroll-mode="PanOnScrollMode.Free"
    :pan-on-scroll="true"
    :default-edge-options="defaultEdgeOptions"
    :connection-mode="ConnectionMode.Loose"
    :nodes-connectable="canManageGraph"
    :nodes-draggable="canManageGraph"
    class="h-full w-full"
    :class="{ 'opacity-0': !layoutReady }"
    @connect-start="onConnectStart"
    @connect-end="onConnectEnd"
  >
    <AddNewTaskToGraph
      v-model="addNewTaskToGraph"
      :goal-id="+projectId"
      :node-position="nodePosition"
      @close="addNewTaskToGraph = false"
      @add-task="addTaskToGraph"
    />

    <Controls />
    <Background />

    <template #node-task="taskNodeProps">
      <TaskNode :data="{ ...taskNodeProps.data, direction: layoutDirection }" />
    </template>

    <!-- Selected Edge Panel -->
    <div
      v-if="selectedEdge"
      class="w-80 max-w-[calc(100%-16px)] absolute bottom-0 left-1/2 -translate-x-1/2 mb-3 z-50 p-3 rounded-lg bg-elevated shadow-lg"
    >
      <p class="text-sm text-muted mb-3">
        {{ t('graph.selectedEdge') }}
      </p>
      <UButton
        icon="i-lucide-trash-2"
        color="error"
        variant="soft"
        class="w-full"
        @click="deleteSelectedEdge(+selectedEdge?.id)"
      >
        {{ t('common.delete') }}
      </UButton>
    </div>

    <!-- Controls Panel -->
    <div class="absolute bottom-4 right-4 z-40 flex gap-2">
      <UButton
        icon="i-lucide-git-graph"
        :variant="layoutDirection === 'LR' ? 'solid' : 'outline'"
        color="neutral"
        class="rotate-90"
        @click="layoutGraph('LR')"
      />
      <UButton
        icon="i-lucide-git-graph"
        :variant="layoutDirection === 'TB' ? 'solid' : 'outline'"
        color="neutral"
        @click="layoutGraph('TB')"
      />
      <UButton
        v-if="canManageGraph"
        icon="i-lucide-plus"
        @click="addNewTaskToGraph = true"
      />
    </div>
  </VueFlow>
</template>

<script setup lang="ts">
import { Background } from '@vue-flow/background'
import { Controls } from '@vue-flow/controls'
import {
  ConnectionMode,
  type DefaultEdgeOptions,
  type Edge,
  MarkerType,
  type OnConnectStartParams,
  PanOnScrollMode,
  useVueFlow,
  VueFlow,
  type XYPosition,
} from '@vue-flow/core'
import { nextTick, ref, watch } from 'vue'
import { useI18n } from 'vue-i18n'
import { storeToRefs } from 'pinia'
import { useGraphStore } from '@/stores/graph.store'
import type { TaskItem } from '@/types/tasks.types'
import type { GraphDirection } from '@/types/graph.types'
import { useGoalPermissions } from '@/composables/useGoalPermissions'
import { useAppRouteInfo } from '@/composables/useAppRouteInfo'
import AddNewTaskToGraph from './AddNewTaskToGraph.vue'
import { estimateNodeSize, layoutCenter, placeNodeInFreeSpot, useLayout } from './composables/useLayout'
import { provideGraphViewportCenter } from './composables/useGraphViewportCenter'
import TaskNode from './TaskNode.vue'

const listIds = defineModel<number[]>('listIds', { default: () => [] })
const assigneeIds = defineModel<number[]>('assigneeIds', { default: () => [] })
const sprintId = defineModel<number | null>('sprintId', { default: null })

const applyFilters = () => {
  let filtered = [...store.allNodes]
  if (listIds.value.length > 0) {
    filtered = filtered.filter((n) => listIds.value.includes(n.data.task.goalListId))
  }
  if (assigneeIds.value.length > 0) {
    filtered = filtered.filter((n) =>
      n.data.task.assignedUsers?.some((id: number) => assigneeIds.value.includes(id)),
    )
  }
  if (sprintId.value != null) {
    filtered = filtered.filter((n) => n.data.task.sprintId === sprintId.value)
  }
  const nodeIds = new Set(filtered.map((n) => n.id))
  store.nodes = filtered
  store.edges = store.allEdges.filter((e) => nodeIds.has(e.source) && nodeIds.has(e.target))
  // Node sizes are estimated from data, so the layout can run right away —
  // no need to wait for nodes to render and be measured
  layoutGraph(layoutDirection.value)
}

watch(listIds, applyFilters, { deep: true })
watch(assigneeIds, applyFilters, { deep: true })
watch(sprintId, applyFilters)

const {
  setCenter,
  onPaneReady,
  onConnect,
  addEdges,
  onEdgesChange,
  onEdgeClick,
  onNodeDragStop,
  removeEdges,
  screenToFlowCoordinate,
  viewport,
  dimensions,
} = useVueFlow()

// Where a new node goes: the middle of what is on screen, or the nearest free spot to it
provideGraphViewportCenter(() => {
  const { width, height } = estimateNodeSize({ data: {} })
  const target = {
    x: Math.round((dimensions.value.width / 2 - viewport.value.x) / viewport.value.zoom - width / 2),
    y: Math.round((dimensions.value.height / 2 - viewport.value.y) / viewport.value.zoom - height / 2),
  }
  return placeNodeInFreeSpot({ target, node: { data: {} }, obstacles: store.nodes })
})

const { projectId } = useAppRouteInfo()
const { layout } = useLayout()
const store = useGraphStore()
const { direction: layoutDirection } = storeToRefs(store)
const { t } = useI18n()
const { canManageGraph, canViewGraph } = useGoalPermissions()

const layoutReady = ref(false)
// A center asked for before the pane was ready, applied once it is
const pendingCenter = ref<XYPosition | null>(null)

const addNewTaskToGraph = ref(false)
const currentSession = ref<number | null>(null)
const successfulSession = ref<number | null>(null)
const targetNodeId = ref<{ event?: MouseEvent } & OnConnectStartParams>()
const nodePosition = ref<{ x: number; y: number } | undefined>(undefined)

const defaultEdgeOptions: DefaultEdgeOptions = {
  type: 'smoothstep',
  animated: false,
  style: {
    strokeWidth: 3,
  },
  markerEnd: {
    type: MarkerType.ArrowClosed,
    width: 22,
    height: 22,
  },
}

const selectedEdge = ref<Edge | null>(null)

watch(
  projectId,
  (id) => {
    if (!id) return
    layoutReady.value = false
    store.fetchAllTasksAndLists(id).then(() => {
      applyFilters()
    })
  },
  { immediate: true },
)

onNodeDragStop((params) => {
  store.updateTaskPosition({
    nodeGraphPosition: { x: params.node.position.x, y: params.node.position.y },
    id: +params.node.id,
  })
})

onConnect(async (params) => {
  if (currentSession.value != null) {
    successfulSession.value = currentSession.value
  }

  const newEdge = await store.addEdge({
    source: +params.source,
    target: +params.target,
  })

  if (!newEdge) return

  addEdges([newEdge])
})

function setAnimatedEdge(id: string | null) {
  store.edges = store.edges.map((edge) => ({ ...edge, animated: edge.id === id }))
}

onEdgesChange((params) => {
  params.forEach((param) => {
    if (param.type === 'select' && !param.selected) {
      selectedEdge.value = null
      setAnimatedEdge(null)
    }
    if (param.type === 'remove') {
      deleteSelectedEdge(+param.id)
      selectedEdge.value = null
    }
  })
})

onEdgeClick((params) => {
  selectedEdge.value = params.edge
  setAnimatedEdge(params.edge.id)
})

const newToken = () => {
  return Date.now() + Math.random()
}

const onConnectStart = (payload: { event?: MouseEvent } & OnConnectStartParams) => {
  const token = newToken()
  currentSession.value = token
  successfulSession.value = null
  targetNodeId.value = payload
}

const onConnectEnd = (event?: MouseEvent | TouchEvent) => {
  if (!event) return

  const { clientX, clientY } = 'changedTouches' in event ? (event as TouchEvent).changedTouches[0] : event

  const el = document.querySelector('[data-id]')
  const position = el?.getBoundingClientRect()

  nodePosition.value = screenToFlowCoordinate({ x: clientX - (position?.width || 2) / 2, y: clientY })

  const isSuccess = currentSession.value != null && successfulSession.value === currentSession.value

  if (!isSuccess) {
    handleCancelledConnection()
  }

  currentSession.value = null
  successfulSession.value = null
}

const handleCancelledConnection = () => {
  addNewTaskToGraph.value = true
}

const addTaskToGraph = async (task: TaskItem) => {
  addNewTaskToGraph.value = false

  await store.addNode(task)

  if (targetNodeId.value && targetNodeId.value.nodeId) {
    const edge = {
      source: +task.id,
      target: +task.id,
    }
    edge[targetNodeId.value.handleType as 'source' | 'target'] = +targetNodeId.value.nodeId
    await store.addEdge(edge)
  }

  nodePosition.value = { x: 0, y: 0 }
  targetNodeId.value = undefined
}

const deleteSelectedEdge = async (id: number) => {
  if (!Number.isFinite(id)) return

  await store.deleteEdge(+id)

  if (selectedEdge.value?.id === id.toString()) {
    selectedEdge.value = null
  }

  removeEdges([id.toString()])
}

// The graph opens at 1:1 around its middle, not fitted as a whole: fitting would
// render every node and defeat only-render-visible-elements. The fit button in
// Controls is still there to see the whole graph
const showLayoutCenter = async () => {
  const center = layoutCenter(store.nodes)
  pendingCenter.value = (await setCenter(center.x, center.y, { zoom: 1 })) ? null : center
}

onPaneReady(() => {
  if (!pendingCenter.value) return
  setCenter(pendingCenter.value.x, pendingCenter.value.y, { zoom: 1 })
  pendingCenter.value = null
})

const layoutGraph = async (direction: GraphDirection) => {
  layoutDirection.value = direction
  store.nodes = layout(store.nodes, store.edges, direction)
  nextTick(async () => {
    await showLayoutCenter()
    layoutReady.value = true
  })
}
</script>

<style>
@import '@vue-flow/core/dist/style.css';
@import '@vue-flow/core/dist/theme-default.css';
@import '@vue-flow/node-resizer/dist/style.css';
@import '@vue-flow/controls/dist/style.css';
@import '@vue-flow/minimap/dist/style.css';
</style>