c21cb29401
→ ← = extend same line (horizontal tracks) ↑ ↓ = new track (parallel line above/below) ↘ ↗ = new track (diagonal fork) Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
1319 lines
41 KiB
Vue
1319 lines
41 KiB
Vue
<script setup>
|
|
import { ref, onMounted, onUnmounted, watch, computed, nextTick } from 'vue'
|
|
import * as d3 from 'd3'
|
|
import { GRID, GRID_STEP_X, GRID_STEP_Y, snapToGrid } from './gridConstants.js'
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Props & Emits
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const props = defineProps({
|
|
dimensions: { type: Object, default: () => ({}) },
|
|
currentPath: { type: Array, default: () => [] },
|
|
|
|
// Legacy flat-prop support
|
|
nodes: { type: Array, default: () => [] },
|
|
lines: { type: Array, default: () => [] },
|
|
connections: { type: Array, default: () => [] },
|
|
currentLevel: { type: Number, default: 1 },
|
|
})
|
|
|
|
const emit = defineEmits([
|
|
'node-click',
|
|
'node-hover',
|
|
'node-leave',
|
|
'dimension-change',
|
|
'create-node',
|
|
'edit-node',
|
|
'delete-node',
|
|
'zoom-change',
|
|
])
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Constants
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const ZOOM_IN_THRESHOLD = 2.5
|
|
const ZOOM_OUT_THRESHOLD = 0.6
|
|
const ZOOM_IN_COMMIT = 4.0
|
|
const ZOOM_OUT_COMMIT = 0.25
|
|
const NODE_PROXIMITY = 250
|
|
const FIT_PADDING = 80 // px padding around nodes for labels
|
|
const FIT_MARGIN = 0.85 // use 85% of viewport
|
|
const FIT_SCALE_MIN = 0.3
|
|
const FIT_SCALE_MAX = 2.0
|
|
|
|
const LINE_COLORS = [
|
|
'#00d2ff', '#e94560', '#00ff88', '#7b68ee',
|
|
'#ff6b6b', '#ffd93d', '#6bcb77', '#4d96ff',
|
|
'#ff8fab', '#a8dadc', '#e07a5f', '#81b29a',
|
|
]
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Refs
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const svgRef = ref(null)
|
|
const containerRef = ref(null)
|
|
const transform = ref(d3.zoomIdentity)
|
|
const hoveredNode = ref(null)
|
|
|
|
// Dimension stack
|
|
const dimensionStack = ref([])
|
|
const currentDimensionIndex = ref(0)
|
|
|
|
// Transition state
|
|
const transitionState = ref({
|
|
active: false,
|
|
direction: null,
|
|
progress: 0,
|
|
targetNode: null,
|
|
childDimension: null,
|
|
})
|
|
|
|
// Tracks whether we're mid-commit (prevent re-entry)
|
|
let isCommitting = false
|
|
|
|
// Grid visibility (shown during branch handle interaction)
|
|
const gridVisible = ref(false)
|
|
let gridFadeTimer = null
|
|
|
|
// Line highlighting (set by FAB hover)
|
|
const highlightedLineId = ref(null)
|
|
|
|
// Context menu
|
|
const contextMenu = ref({
|
|
show: false,
|
|
x: 0, y: 0,
|
|
type: null,
|
|
node: null,
|
|
canvasX: 0, canvasY: 0,
|
|
})
|
|
|
|
// D3 references
|
|
let svg, g, zoom
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Derived helpers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const getLineColor = (index) => LINE_COLORS[index % LINE_COLORS.length]
|
|
|
|
const currentDimensionData = computed(() => {
|
|
return dimensionStack.value[currentDimensionIndex.value] ?? null
|
|
})
|
|
|
|
const currentNodes = computed(() => {
|
|
return currentDimensionData.value?.nodes ?? []
|
|
})
|
|
|
|
const currentDepth = computed(() => currentDimensionIndex.value + 1)
|
|
|
|
/** Whether we're currently inside a child dimension (not root) */
|
|
const isInChildDimension = computed(() => currentDimensionIndex.value > 0)
|
|
|
|
/** The parent node we zoomed into (if in child dimension) */
|
|
const parentNode = computed(() => {
|
|
if (!isInChildDimension.value) return null
|
|
return currentDimensionData.value?.parentNodeId ?? null
|
|
})
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Bootstrap dimension stack from props
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const buildRootDimension = () => {
|
|
if (props.dimensions && (props.dimensions.nodes || props.dimensions.lines)) {
|
|
return {
|
|
id: 'root',
|
|
parentNodeId: null,
|
|
lines: props.dimensions.lines ?? [],
|
|
nodes: props.dimensions.nodes ?? [],
|
|
connections: props.dimensions.connections ?? [],
|
|
opacity: 1,
|
|
}
|
|
}
|
|
return {
|
|
id: 'root',
|
|
parentNodeId: null,
|
|
lines: props.lines ?? [],
|
|
nodes: props.nodes ?? [],
|
|
connections: props.connections ?? [],
|
|
opacity: 1,
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Fit-to-view transform
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Compute a D3 zoom transform that fits all nodes of a dimension into the
|
|
* viewport with padding, instead of always resetting to scale=1.
|
|
*/
|
|
const computeFitTransform = (dimData, w, h) => {
|
|
const nodes = dimData?.nodes ?? []
|
|
if (!nodes.length) {
|
|
return d3.zoomIdentity.translate(w / 2, h / 2).scale(1)
|
|
}
|
|
|
|
const xMin = Math.min(...nodes.map(n => n.x)) - FIT_PADDING
|
|
const xMax = Math.max(...nodes.map(n => n.x)) + FIT_PADDING
|
|
const yMin = Math.min(...nodes.map(n => n.y)) - FIT_PADDING
|
|
const yMax = Math.max(...nodes.map(n => n.y)) + FIT_PADDING
|
|
|
|
// Guard against degenerate bbox (single node or co-linear)
|
|
const bboxW = Math.max(xMax - xMin, 100)
|
|
const bboxH = Math.max(yMax - yMin, 100)
|
|
|
|
const scaleX = (w * FIT_MARGIN) / bboxW
|
|
const scaleY = (h * FIT_MARGIN) / bboxH
|
|
const scale = Math.min(Math.max(Math.min(scaleX, scaleY), FIT_SCALE_MIN), FIT_SCALE_MAX)
|
|
|
|
const bboxCenterX = (xMin + xMax) / 2
|
|
const bboxCenterY = (yMin + yMax) / 2
|
|
|
|
const tx = w / 2 - bboxCenterX * scale
|
|
const ty = h / 2 - bboxCenterY * scale
|
|
|
|
return d3.zoomIdentity.translate(tx, ty).scale(scale)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Canvas init
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const initCanvas = () => {
|
|
if (!svgRef.value) return
|
|
|
|
const width = containerRef.value.clientWidth
|
|
const height = containerRef.value.clientHeight
|
|
|
|
svg = d3.select(svgRef.value)
|
|
.attr('width', width)
|
|
.attr('height', height)
|
|
|
|
svg.selectAll('*').remove()
|
|
|
|
// --- Defs ---
|
|
const defs = svg.append('defs')
|
|
|
|
const glowFilter = defs.append('filter')
|
|
.attr('id', 'glow')
|
|
.attr('x', '-50%').attr('y', '-50%')
|
|
.attr('width', '200%').attr('height', '200%')
|
|
|
|
glowFilter.append('feGaussianBlur')
|
|
.attr('stdDeviation', '4')
|
|
.attr('result', 'coloredBlur')
|
|
|
|
const feMerge = glowFilter.append('feMerge')
|
|
feMerge.append('feMergeNode').attr('in', 'coloredBlur')
|
|
feMerge.append('feMergeNode').attr('in', 'SourceGraphic')
|
|
|
|
const childGlowFilter = defs.append('filter')
|
|
.attr('id', 'childGlow')
|
|
.attr('x', '-100%').attr('y', '-100%')
|
|
.attr('width', '300%').attr('height', '300%')
|
|
|
|
childGlowFilter.append('feGaussianBlur')
|
|
.attr('stdDeviation', '2')
|
|
.attr('result', 'coloredBlur')
|
|
|
|
const feMerge2 = childGlowFilter.append('feMerge')
|
|
feMerge2.append('feMergeNode').attr('in', 'coloredBlur')
|
|
feMerge2.append('feMergeNode').attr('in', 'SourceGraphic')
|
|
|
|
// Main panning/zooming group
|
|
g = svg.append('g')
|
|
|
|
// --- Zoom ---
|
|
zoom = d3.zoom()
|
|
.scaleExtent([0.15, 6])
|
|
.on('zoom', handleZoom)
|
|
|
|
svg.call(zoom)
|
|
|
|
// Right-click context menu
|
|
svg.on('contextmenu', (event) => {
|
|
event.preventDefault()
|
|
const [x, y] = d3.pointer(event, g.node())
|
|
const clickedNode = findNodeAt(x, y)
|
|
contextMenu.value = {
|
|
show: true,
|
|
x: event.clientX,
|
|
y: event.clientY,
|
|
type: clickedNode ? 'node' : 'canvas',
|
|
node: clickedNode,
|
|
canvasX: x,
|
|
canvasY: y,
|
|
}
|
|
})
|
|
|
|
// Seed the dimension stack with root data
|
|
dimensionStack.value = [buildRootDimension()]
|
|
currentDimensionIndex.value = 0
|
|
|
|
// Fit initial view to the data instead of hardcoded scale=1
|
|
const rootDim = dimensionStack.value[0]
|
|
svg.call(zoom.transform, computeFitTransform(rootDim, width, height))
|
|
|
|
renderMap()
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Zoom handler
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const handleZoom = (event) => {
|
|
const t = event.transform
|
|
g.attr('transform', t)
|
|
transform.value = t
|
|
|
|
// During commit animation, just apply the visual transform — skip threshold logic
|
|
if (isCommitting) return
|
|
|
|
emit('zoom-change', { scale: t.k, x: t.x, y: t.y })
|
|
|
|
const w = containerRef.value?.clientWidth ?? 800
|
|
const h = containerRef.value?.clientHeight ?? 600
|
|
const cx = (w / 2 - t.x) / t.k
|
|
const cy = (h / 2 - t.y) / t.k
|
|
const nearest = findNearestNode(cx, cy)
|
|
|
|
// --- Zoom-in transition ---
|
|
if (t.k > ZOOM_IN_THRESHOLD &&
|
|
nearest &&
|
|
nearest.node.children &&
|
|
nearest.distance < NODE_PROXIMITY)
|
|
{
|
|
const range = ZOOM_IN_COMMIT - ZOOM_IN_THRESHOLD
|
|
const progress = Math.min(1, Math.max(0, (t.k - ZOOM_IN_THRESHOLD) / range))
|
|
|
|
transitionState.value = {
|
|
active: true,
|
|
direction: 'in',
|
|
progress,
|
|
targetNode: nearest.node,
|
|
childDimension: nearest.node.children,
|
|
}
|
|
|
|
renderWithTransition()
|
|
|
|
if (progress >= 1) {
|
|
commitDimensionChange('in', nearest.node)
|
|
}
|
|
return
|
|
}
|
|
|
|
// --- Zoom-out transition ---
|
|
if (t.k < ZOOM_OUT_THRESHOLD && dimensionStack.value.length > 1) {
|
|
const range = ZOOM_OUT_THRESHOLD - ZOOM_OUT_COMMIT
|
|
const progress = Math.min(1, Math.max(0, (ZOOM_OUT_THRESHOLD - t.k) / range))
|
|
|
|
transitionState.value = {
|
|
active: true,
|
|
direction: 'out',
|
|
progress,
|
|
targetNode: null,
|
|
childDimension: null,
|
|
}
|
|
|
|
renderWithTransition()
|
|
|
|
if (progress >= 1) {
|
|
commitDimensionChange('out', null)
|
|
}
|
|
return
|
|
}
|
|
|
|
// --- Normal range: cancel any ongoing transition ---
|
|
if (transitionState.value.active) {
|
|
transitionState.value.active = false
|
|
}
|
|
renderMap()
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Dimension commit
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const commitDimensionChange = (direction, node) => {
|
|
if (isCommitting) return
|
|
isCommitting = true
|
|
|
|
if (direction === 'in' && node) {
|
|
const children = node.children
|
|
const child = {
|
|
id: node.id,
|
|
parentNodeId: node.id,
|
|
// Prefer metadata from backend, fall back to node's own entity info
|
|
parentEntityType: children.parentEntityType ?? node.entityType ?? null,
|
|
parentEntityId: children.parentEntityId ?? node.entityId ?? null,
|
|
parentName: children.parentName ?? node.name ?? null,
|
|
lines: children.lines ?? [],
|
|
nodes: children.nodes ?? [],
|
|
connections: children.connections ?? [],
|
|
opacity: 1,
|
|
}
|
|
dimensionStack.value.push(child)
|
|
currentDimensionIndex.value++
|
|
|
|
animateZoomReset()
|
|
|
|
transitionState.value.active = false
|
|
emit('dimension-change', {
|
|
direction: 'in',
|
|
node,
|
|
depth: dimensionStack.value.length,
|
|
dimension: child,
|
|
})
|
|
} else if (direction === 'out') {
|
|
dimensionStack.value.pop()
|
|
currentDimensionIndex.value = Math.max(0, currentDimensionIndex.value - 1)
|
|
|
|
animateZoomReset()
|
|
|
|
transitionState.value.active = false
|
|
emit('dimension-change', {
|
|
direction: 'out',
|
|
depth: dimensionStack.value.length,
|
|
dimension: currentDimensionData.value,
|
|
})
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Smoothly animate to a fit-to-view transform for the current dimension.
|
|
* Calculates bounding box of all nodes and zooms to fit them in the viewport.
|
|
* The zoom handler stays active but isCommitting guards against threshold logic.
|
|
*/
|
|
const animateZoomReset = () => {
|
|
if (!svg || !zoom) {
|
|
isCommitting = false
|
|
renderMap()
|
|
return
|
|
}
|
|
|
|
const w = containerRef.value?.clientWidth ?? 800
|
|
const h = containerRef.value?.clientHeight ?? 600
|
|
|
|
const targetDim = currentDimensionData.value
|
|
const targetTransform = computeFitTransform(targetDim, w, h)
|
|
|
|
// Render the new dimension immediately so the animation shows correct content
|
|
renderMap()
|
|
|
|
svg.transition()
|
|
.duration(400)
|
|
.ease(d3.easeCubicOut)
|
|
.call(zoom.transform, targetTransform)
|
|
.on('end', () => {
|
|
isCommitting = false
|
|
renderMap()
|
|
})
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Node finders
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const findNearestNode = (x, y) => {
|
|
const nodes = currentNodes.value
|
|
if (!nodes.length) return null
|
|
let nearest = null
|
|
let minDist = Infinity
|
|
for (const node of nodes) {
|
|
const dist = Math.sqrt((node.x - x) ** 2 + (node.y - y) ** 2)
|
|
if (dist < minDist) {
|
|
minDist = dist
|
|
nearest = { node, distance: dist }
|
|
}
|
|
}
|
|
return nearest
|
|
}
|
|
|
|
const findNodeAt = (x, y, dimData = null) => {
|
|
const nodes = dimData?.nodes ?? currentNodes.value
|
|
return nodes.find(n => Math.sqrt((n.x - x) ** 2 + (n.y - y) ** 2) < 15) ?? null
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Grid rendering (shown on interaction only)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const renderGrid = (dimData, parentGroup) => {
|
|
const nodes = dimData?.nodes ?? []
|
|
if (!nodes.length) return
|
|
|
|
const gridGroup = parentGroup.append('g')
|
|
.attr('class', 'grid-layer')
|
|
.attr('opacity', gridVisible.value ? 0.6 : 0)
|
|
.style('transition', 'opacity 0.3s ease')
|
|
|
|
const margin = 300
|
|
const xMin = Math.min(...nodes.map(n => n.x)) - margin
|
|
const xMax = Math.max(...nodes.map(n => n.x)) + margin
|
|
const yMin = Math.min(...nodes.map(n => n.y)) - margin
|
|
const yMax = Math.max(...nodes.map(n => n.y)) + margin
|
|
|
|
for (let x = snapToGrid(xMin); x <= xMax; x += GRID_STEP_X) {
|
|
gridGroup.append('line')
|
|
.attr('x1', x).attr('y1', yMin)
|
|
.attr('x2', x).attr('y2', yMax)
|
|
.attr('stroke', 'rgba(0, 210, 255, 0.06)')
|
|
.attr('stroke-width', 0.5)
|
|
.attr('stroke-dasharray', '2,6')
|
|
}
|
|
for (let y = snapToGrid(yMin); y <= yMax; y += GRID_STEP_Y) {
|
|
gridGroup.append('line')
|
|
.attr('x1', xMin).attr('y1', y)
|
|
.attr('x2', xMax).attr('y2', y)
|
|
.attr('stroke', 'rgba(0, 210, 255, 0.06)')
|
|
.attr('stroke-width', 0.5)
|
|
.attr('stroke-dasharray', '2,6')
|
|
}
|
|
}
|
|
|
|
const showGrid = () => {
|
|
clearTimeout(gridFadeTimer)
|
|
gridVisible.value = true
|
|
if (g) g.select('.grid-layer').transition().duration(200).attr('opacity', 0.6)
|
|
}
|
|
|
|
const hideGrid = () => {
|
|
gridFadeTimer = setTimeout(() => {
|
|
gridVisible.value = false
|
|
if (g) g.select('.grid-layer').transition().duration(300).attr('opacity', 0)
|
|
}, 400)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Branch handles
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Render branch handles on a hovered node.
|
|
* 0° = extend line right, 45° = fork down-right, 315° = fork up-right.
|
|
*/
|
|
const renderBranchHandles = (nodeGroup, node, allNodes) => {
|
|
// Remove any existing handles first
|
|
nodeGroup.select('.branch-handles').remove()
|
|
|
|
const handleGroup = nodeGroup.append('g').attr('class', 'branch-handles')
|
|
const HANDLE_DIST = 30 // distance from node center to handle
|
|
const HANDLE_R = 9 // handle circle radius
|
|
|
|
const branches = [
|
|
{ deg: 0, dx: GRID_STEP_X, dy: 0, label: '→' }, // extend right
|
|
{ deg: 90, dx: 0, dy: GRID_STEP_Y, label: '↓' }, // extend down
|
|
{ deg: 180, dx: -GRID_STEP_X, dy: 0, label: '←' }, // extend left
|
|
{ deg: 270, dx: 0, dy: -GRID_STEP_Y, label: '↑' }, // extend up
|
|
{ deg: 45, dx: GRID_STEP_X, dy: GRID_STEP_Y, label: '↘' }, // fork down-right
|
|
{ deg: 315, dx: GRID_STEP_X, dy: -GRID_STEP_Y, label: '↗' }, // fork up-right
|
|
]
|
|
|
|
branches.forEach(b => {
|
|
const targetX = snapToGrid(node.x + b.dx)
|
|
const targetY = snapToGrid(node.y + b.dy)
|
|
|
|
// Allow branching to occupied positions — metro interchanges are valid
|
|
const occupied = allNodes.some(n => n.x === targetX && n.y === targetY)
|
|
|
|
const rad = (b.deg * Math.PI) / 180
|
|
const hx = Math.cos(rad) * HANDLE_DIST
|
|
const hy = Math.sin(rad) * HANDLE_DIST
|
|
|
|
// Handle circle
|
|
const handle = handleGroup.append('circle')
|
|
.attr('cx', hx).attr('cy', hy)
|
|
.attr('r', HANDLE_R)
|
|
.attr('fill', 'rgba(0, 210, 255, 0.1)')
|
|
.attr('stroke', '#00d2ff')
|
|
.attr('stroke-width', 1.5)
|
|
.attr('stroke-dasharray', '3,2')
|
|
.attr('cursor', 'pointer')
|
|
.attr('class', 'branch-handle')
|
|
.attr('opacity', 0)
|
|
.transition().duration(200)
|
|
.attr('opacity', 0.8)
|
|
|
|
// "+" text on handle
|
|
handleGroup.append('text')
|
|
.attr('x', hx).attr('y', hy + 4)
|
|
.attr('text-anchor', 'middle')
|
|
.attr('fill', '#00d2ff')
|
|
.attr('font-family', "'VT323', monospace")
|
|
.attr('font-size', '13px')
|
|
.attr('pointer-events', 'none')
|
|
.attr('opacity', 0)
|
|
.transition().duration(200)
|
|
.attr('opacity', 0.9)
|
|
.text('+')
|
|
|
|
// Invisible larger hit area for the handle
|
|
handleGroup.append('circle')
|
|
.attr('cx', hx).attr('cy', hy)
|
|
.attr('r', HANDLE_R + 6)
|
|
.attr('fill', 'transparent')
|
|
.attr('cursor', 'pointer')
|
|
.on('mouseenter', () => {
|
|
// Ghost preview: dashed line + ghost circle at target
|
|
handleGroup.selectAll('.ghost-preview').remove()
|
|
handleGroup.append('line')
|
|
.attr('class', 'ghost-preview')
|
|
.attr('x1', 0).attr('y1', 0)
|
|
.attr('x2', b.dx).attr('y2', b.dy)
|
|
.attr('stroke', '#00d2ff')
|
|
.attr('stroke-width', 2)
|
|
.attr('stroke-dasharray', '6,4')
|
|
.attr('opacity', 0.4)
|
|
handleGroup.append('circle')
|
|
.attr('class', 'ghost-preview')
|
|
.attr('cx', b.dx).attr('cy', b.dy)
|
|
.attr('r', 8)
|
|
.attr('fill', 'none')
|
|
.attr('stroke', '#00d2ff')
|
|
.attr('stroke-width', 1.5)
|
|
.attr('stroke-dasharray', '4,3')
|
|
.attr('opacity', 0.5)
|
|
handleGroup.append('text')
|
|
.attr('class', 'ghost-preview')
|
|
.attr('x', b.dx).attr('y', b.dy + 28)
|
|
.attr('text-anchor', 'middle')
|
|
.attr('fill', '#00d2ff')
|
|
.attr('font-family', "'VT323', monospace")
|
|
.attr('font-size', '12px')
|
|
.attr('opacity', 0.5)
|
|
.text(occupied ? 'interchange' : ([0, 180].includes(b.deg) ? 'extend' : 'new track'))
|
|
})
|
|
.on('mouseleave', () => {
|
|
handleGroup.selectAll('.ghost-preview').remove()
|
|
})
|
|
.on('click', (event) => {
|
|
event.stopPropagation()
|
|
emit('create-node', {
|
|
x: targetX,
|
|
y: targetY,
|
|
lineId: [0, 180].includes(b.deg) ? node.lineId : null, // horizontal = same line, vertical + diagonal = new track
|
|
afterNodeId: node.id,
|
|
branchAngle: b.deg,
|
|
parentNodeId: currentDimensionData.value?.parentNodeId ?? null,
|
|
parentEntityType: currentDimensionData.value?.parentEntityType ?? null,
|
|
parentEntityId: currentDimensionData.value?.parentEntityId ?? null,
|
|
dimensionId: currentDimensionData.value?.id ?? 'root',
|
|
depth: currentDepth.value,
|
|
sourceNode: node,
|
|
})
|
|
})
|
|
})
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Rendering
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const renderDimension = (dimData, opacity, parentGroup) => {
|
|
if (!dimData) return
|
|
|
|
const group = parentGroup.append('g')
|
|
.attr('opacity', opacity)
|
|
.attr('class', 'dimension-group')
|
|
.style('transition', 'opacity 0.05s linear')
|
|
|
|
// Grid layer (behind everything, only visible during interaction)
|
|
renderGrid(dimData, group)
|
|
|
|
const nodes = dimData.nodes ?? []
|
|
const lines = dimData.lines ?? []
|
|
const connections = dimData.connections ?? []
|
|
|
|
// --- Metro lines ---
|
|
lines.forEach((line, lineIndex) => {
|
|
const color = line.color || getLineColor(lineIndex)
|
|
const isHighlighted = highlightedLineId.value === line.id
|
|
const isAnyHighlighted = highlightedLineId.value !== null
|
|
const lineNodes = nodes
|
|
.filter(n => n.lineId === line.id)
|
|
.sort((a, b) => a.order - b.order)
|
|
|
|
if (lineNodes.length < 2) {
|
|
// Still render a single node's line label
|
|
if (lineNodes.length === 1) {
|
|
group.append('text')
|
|
.attr('x', lineNodes[0].x - 10)
|
|
.attr('y', lineNodes[0].y - 35)
|
|
.attr('fill', color)
|
|
.attr('font-family', "'VT323', monospace")
|
|
.attr('font-size', '16px')
|
|
.attr('opacity', 0.85)
|
|
.text(line.name)
|
|
}
|
|
if (lineNodes.length < 2) return
|
|
}
|
|
|
|
const lineGen = d3.line()
|
|
.x(d => d.x)
|
|
.y(d => d.y)
|
|
.curve(d3.curveMonotoneX)
|
|
|
|
const trackOpacity = isAnyHighlighted ? (isHighlighted ? 1.0 : 0.2) : 0.75
|
|
const glowOpacity = isAnyHighlighted ? (isHighlighted ? 0.3 : 0.05) : 0.15
|
|
|
|
// Outer glow track
|
|
group.append('path')
|
|
.datum(lineNodes)
|
|
.attr('d', lineGen)
|
|
.attr('fill', 'none')
|
|
.attr('stroke', color)
|
|
.attr('stroke-width', isHighlighted ? 10 : 8)
|
|
.attr('stroke-linecap', 'round')
|
|
.attr('opacity', glowOpacity)
|
|
.attr('filter', isHighlighted ? 'url(#glow)' : null)
|
|
|
|
// Main track
|
|
group.append('path')
|
|
.datum(lineNodes)
|
|
.attr('d', lineGen)
|
|
.attr('fill', 'none')
|
|
.attr('stroke', color)
|
|
.attr('stroke-width', isHighlighted ? 5 : 4)
|
|
.attr('stroke-linecap', 'round')
|
|
.attr('opacity', trackOpacity)
|
|
|
|
// Line label
|
|
if (lineNodes.length > 0) {
|
|
group.append('text')
|
|
.attr('x', lineNodes[0].x - 10)
|
|
.attr('y', lineNodes[0].y - 35)
|
|
.attr('fill', color)
|
|
.attr('font-family', "'VT323', monospace")
|
|
.attr('font-size', '16px')
|
|
.attr('opacity', 0.85)
|
|
.text(line.name)
|
|
}
|
|
})
|
|
|
|
// --- Dependency connections ---
|
|
connections.forEach(conn => {
|
|
const source = nodes.find(n => n.id === conn.from)
|
|
const target = nodes.find(n => n.id === conn.to)
|
|
if (!source || !target) return
|
|
|
|
group.append('line')
|
|
.attr('x1', source.x).attr('y1', source.y)
|
|
.attr('x2', target.x).attr('y2', target.y)
|
|
.attr('stroke', '#8892b0')
|
|
.attr('stroke-width', 1.5)
|
|
.attr('stroke-dasharray', '6,4')
|
|
.attr('opacity', 0.4)
|
|
})
|
|
|
|
// --- Station nodes ---
|
|
const nodeGroups = group.selectAll('.station')
|
|
.data(nodes)
|
|
.enter()
|
|
.append('g')
|
|
.attr('class', 'station')
|
|
.attr('transform', d => `translate(${d.x}, ${d.y})`)
|
|
.attr('cursor', 'pointer')
|
|
.on('click', (event, d) => {
|
|
event.stopPropagation()
|
|
emit('node-click', d)
|
|
})
|
|
.on('mouseenter', (event, d) => {
|
|
hoveredNode.value = d
|
|
d3.select(event.currentTarget).select('.station-dot')
|
|
.transition().duration(200)
|
|
.attr('r', 12)
|
|
.attr('filter', 'url(#glow)')
|
|
|
|
// Show branch handles
|
|
showGrid()
|
|
renderBranchHandles(d3.select(event.currentTarget), d, nodes)
|
|
|
|
emit('node-hover', d)
|
|
})
|
|
.on('mouseleave', (event, d) => {
|
|
hoveredNode.value = null
|
|
d3.select(event.currentTarget).select('.station-dot')
|
|
.transition().duration(200)
|
|
.attr('r', 8)
|
|
.attr('filter', null)
|
|
|
|
// Remove branch handles
|
|
d3.select(event.currentTarget).select('.branch-handles').remove()
|
|
hideGrid()
|
|
|
|
emit('node-leave', d)
|
|
})
|
|
|
|
// Outer ring
|
|
nodeGroups.append('circle')
|
|
.attr('r', 11)
|
|
.attr('fill', 'none')
|
|
.attr('stroke', d => {
|
|
const line = lines.find(l => l.id === d.lineId)
|
|
return line?.color || getLineColor(lines.indexOf(line))
|
|
})
|
|
.attr('stroke-width', 2)
|
|
|
|
// Inner dot
|
|
nodeGroups.append('circle')
|
|
.attr('class', 'station-dot')
|
|
.attr('r', 8)
|
|
.attr('fill', d => {
|
|
if (d.status === 'afgerond' || d.status === 'completed') return '#00ff88'
|
|
if (d.status === 'actief' || d.status === 'active') return '#00d2ff'
|
|
if (d.status === 'geparkeerd') return '#ffd93d'
|
|
if (d.status === 'gestopt') return '#e94560'
|
|
return '#16213e'
|
|
})
|
|
.attr('stroke', d => {
|
|
const line = lines.find(l => l.id === d.lineId)
|
|
return line?.color || getLineColor(lines.indexOf(line))
|
|
})
|
|
.attr('stroke-width', 2)
|
|
|
|
// Child-dimension indicator: populated dimension (has nodes inside)
|
|
nodeGroups.filter(d => d.children && (d.children.nodes?.length ?? 0) > 0)
|
|
.append('circle')
|
|
.attr('r', 16)
|
|
.attr('fill', 'none')
|
|
.attr('stroke', '#00d2ff')
|
|
.attr('stroke-width', 1)
|
|
.attr('stroke-dasharray', '3,3')
|
|
.attr('opacity', 0.5)
|
|
.attr('filter', 'url(#childGlow)')
|
|
|
|
nodeGroups.filter(d => d.children && (d.children.nodes?.length ?? 0) > 0)
|
|
.append('text')
|
|
.attr('x', 13)
|
|
.attr('y', -13)
|
|
.attr('fill', '#00d2ff')
|
|
.attr('font-family', "'VT323', monospace")
|
|
.attr('font-size', '11px')
|
|
.attr('opacity', 0.8)
|
|
.text('[+]')
|
|
|
|
// Empty dimension indicator (dimension exists but no nodes yet)
|
|
nodeGroups.filter(d => d.children && (d.children.nodes?.length ?? 0) === 0)
|
|
.append('circle')
|
|
.attr('r', 14)
|
|
.attr('fill', 'none')
|
|
.attr('stroke', '#8892b0')
|
|
.attr('stroke-width', 0.8)
|
|
.attr('stroke-dasharray', '2,4')
|
|
.attr('opacity', 0.4)
|
|
|
|
nodeGroups.filter(d => d.children && (d.children.nodes?.length ?? 0) === 0)
|
|
.append('text')
|
|
.attr('x', 13)
|
|
.attr('y', -13)
|
|
.attr('fill', '#8892b0')
|
|
.attr('font-family', "'VT323', monospace")
|
|
.attr('font-size', '10px')
|
|
.attr('opacity', 0.5)
|
|
.text('[○]')
|
|
|
|
// Station label
|
|
nodeGroups.append('text')
|
|
.attr('x', 0)
|
|
.attr('y', 28)
|
|
.attr('text-anchor', 'middle')
|
|
.attr('fill', '#e8e8e8')
|
|
.attr('font-family', "'VT323', monospace")
|
|
.attr('font-size', '14px')
|
|
.text(d => d.name)
|
|
|
|
// Status badge
|
|
nodeGroups.filter(d => d.badge)
|
|
.append('text')
|
|
.attr('x', 0)
|
|
.attr('y', 42)
|
|
.attr('text-anchor', 'middle')
|
|
.attr('fill', '#8892b0')
|
|
.attr('font-family', "'IBM Plex Mono', monospace")
|
|
.attr('font-size', '10px')
|
|
.text(d => d.badge)
|
|
}
|
|
|
|
/** Normal render */
|
|
const renderMap = () => {
|
|
if (!g) return
|
|
g.selectAll('*').remove()
|
|
const dim = currentDimensionData.value
|
|
if (dim) renderDimension(dim, 1, g)
|
|
}
|
|
|
|
/** Cross-fade render during a zoom transition */
|
|
const renderWithTransition = () => {
|
|
if (!g) return
|
|
g.selectAll('*').remove()
|
|
|
|
const { progress, direction, childDimension } = transitionState.value
|
|
const eased = d3.easeCubicInOut(progress)
|
|
|
|
if (direction === 'in') {
|
|
renderDimension(currentDimensionData.value, 1 - eased, g)
|
|
if (childDimension) {
|
|
renderDimension(
|
|
{
|
|
lines: childDimension.lines ?? [],
|
|
nodes: childDimension.nodes ?? [],
|
|
connections: childDimension.connections ?? [],
|
|
},
|
|
eased,
|
|
g
|
|
)
|
|
}
|
|
} else if (direction === 'out' && dimensionStack.value.length > 1) {
|
|
renderDimension(currentDimensionData.value, 1 - eased, g)
|
|
const parentDim = dimensionStack.value[currentDimensionIndex.value - 1]
|
|
if (parentDim) {
|
|
renderDimension(parentDim, eased, g)
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Context menu handlers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const closeContextMenu = () => {
|
|
contextMenu.value.show = false
|
|
}
|
|
|
|
const handleContextCreate = () => {
|
|
emit('create-node', {
|
|
x: contextMenu.value.canvasX,
|
|
y: contextMenu.value.canvasY,
|
|
parentNodeId: currentDimensionData.value?.parentNodeId ?? null,
|
|
parentEntityType: currentDimensionData.value?.parentEntityType ?? null,
|
|
parentEntityId: currentDimensionData.value?.parentEntityId ?? null,
|
|
dimensionId: currentDimensionData.value?.id ?? 'root',
|
|
depth: currentDepth.value,
|
|
})
|
|
closeContextMenu()
|
|
}
|
|
|
|
const handleContextEdit = () => {
|
|
if (contextMenu.value.node) emit('edit-node', contextMenu.value.node)
|
|
closeContextMenu()
|
|
}
|
|
|
|
/** "Add dimension" — attach an empty children object to a node, making it zoomable */
|
|
const handleContextAddDimension = () => {
|
|
const node = contextMenu.value.node
|
|
if (!node) { closeContextMenu(); return }
|
|
|
|
// Create empty dimension structure on the node
|
|
node.children = {
|
|
lines: [],
|
|
nodes: [],
|
|
connections: [],
|
|
parentEntityType: node.entityType ?? null,
|
|
parentEntityId: node.entityId ?? null,
|
|
parentName: node.name ?? null,
|
|
}
|
|
|
|
// Re-render to show the new [○] indicator
|
|
renderMap()
|
|
closeContextMenu()
|
|
}
|
|
|
|
/** "Open dimension" — zoom into a node that already has children */
|
|
const handleContextZoomIn = () => {
|
|
const node = contextMenu.value.node
|
|
if (!node?.children) { closeContextMenu(); return }
|
|
|
|
closeContextMenu()
|
|
commitDimensionChange('in', node)
|
|
}
|
|
|
|
const handleContextDelete = () => {
|
|
if (contextMenu.value.node) emit('delete-node', contextMenu.value.node)
|
|
closeContextMenu()
|
|
}
|
|
|
|
/** FAB creates a node in the current dimension */
|
|
const handleFabCreate = () => {
|
|
emit('create-node', {
|
|
x: 0, y: 0,
|
|
parentNodeId: currentDimensionData.value?.parentNodeId ?? null,
|
|
parentEntityType: currentDimensionData.value?.parentEntityType ?? null,
|
|
parentEntityId: currentDimensionData.value?.parentEntityId ?? null,
|
|
dimensionId: currentDimensionData.value?.id ?? 'root',
|
|
depth: currentDepth.value,
|
|
})
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Resize
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const handleResize = () => {
|
|
if (!svg || !containerRef.value) return
|
|
svg.attr('width', containerRef.value.clientWidth)
|
|
.attr('height', containerRef.value.clientHeight)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Document click to close context menu
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const onDocumentClick = (e) => {
|
|
if (contextMenu.value.show) {
|
|
closeContextMenu()
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Watchers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
watch(
|
|
() => [props.nodes, props.lines, props.connections, props.dimensions],
|
|
() => {
|
|
if (dimensionStack.value.length > 0) {
|
|
dimensionStack.value[0] = buildRootDimension()
|
|
} else {
|
|
dimensionStack.value = [buildRootDimension()]
|
|
}
|
|
if (!transitionState.value.active) {
|
|
renderMap()
|
|
}
|
|
},
|
|
{ deep: true }
|
|
)
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Lifecycle
|
|
// ---------------------------------------------------------------------------
|
|
|
|
onMounted(() => {
|
|
initCanvas()
|
|
window.addEventListener('resize', handleResize)
|
|
document.addEventListener('click', onDocumentClick)
|
|
})
|
|
|
|
onUnmounted(() => {
|
|
window.removeEventListener('resize', handleResize)
|
|
document.removeEventListener('click', onDocumentClick)
|
|
})
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Exposed API
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const zoomTo = (x, y, scale) => {
|
|
if (!svg || !zoom) return
|
|
svg.transition().duration(500).call(
|
|
zoom.transform,
|
|
d3.zoomIdentity.translate(x, y).scale(scale)
|
|
)
|
|
}
|
|
|
|
const setHighlightedLine = (lineId) => {
|
|
highlightedLineId.value = lineId
|
|
renderMap()
|
|
}
|
|
|
|
defineExpose({
|
|
zoomTo,
|
|
handleFabCreate,
|
|
currentDepth,
|
|
currentDimensionData,
|
|
isInChildDimension,
|
|
setHighlightedLine,
|
|
showGrid,
|
|
hideGrid,
|
|
})
|
|
</script>
|
|
|
|
<template>
|
|
<div ref="containerRef" class="metro-canvas-container" @click="closeContextMenu">
|
|
|
|
<!-- Main SVG canvas -->
|
|
<svg ref="svgRef" class="metro-canvas"></svg>
|
|
|
|
<!-- Depth indicator -->
|
|
<div class="depth-indicator">
|
|
DEPTH: {{ currentDepth }}
|
|
<span v-if="currentDepth > 1" class="depth-back" @click.stop="commitDimensionChange('out', null)">
|
|
[↑ BACK]
|
|
</span>
|
|
</div>
|
|
|
|
<!-- Transition progress bar -->
|
|
<div
|
|
v-if="transitionState.active"
|
|
class="transition-bar"
|
|
:style="{ width: (transitionState.progress * 100) + '%' }"
|
|
></div>
|
|
|
|
<!-- Hover tooltip -->
|
|
<Transition name="fade">
|
|
<div
|
|
v-if="hoveredNode"
|
|
class="node-tooltip"
|
|
:style="{
|
|
left: `${hoveredNode.x * transform.k + transform.x - 280}px`,
|
|
top: `${hoveredNode.y * transform.k + transform.y - 20}px`,
|
|
}"
|
|
>
|
|
<div class="tooltip-title">{{ hoveredNode.name }}</div>
|
|
<div v-if="hoveredNode.description" class="tooltip-desc">{{ hoveredNode.description }}</div>
|
|
<div v-if="hoveredNode.status" class="tooltip-status">{{ hoveredNode.status }}</div>
|
|
<div v-if="hoveredNode.children && (hoveredNode.children.nodes?.length ?? 0) > 0" class="tooltip-hint">
|
|
Scroll to zoom in → child dimension
|
|
</div>
|
|
<div v-else class="tooltip-hint">Click to view details</div>
|
|
</div>
|
|
</Transition>
|
|
|
|
<!-- Context menu -->
|
|
<Transition name="menu-fade">
|
|
<div
|
|
v-if="contextMenu.show"
|
|
class="context-menu"
|
|
:style="{ left: contextMenu.x + 'px', top: contextMenu.y + 'px' }"
|
|
@click.stop
|
|
>
|
|
<template v-if="contextMenu.type === 'canvas'">
|
|
<div class="context-menu-header">CANVAS</div>
|
|
<div class="context-hint">Hover a station to branch</div>
|
|
</template>
|
|
<template v-else-if="contextMenu.type === 'node'">
|
|
<div class="context-menu-header">{{ contextMenu.node?.name ?? 'NODE' }}</div>
|
|
<button class="context-item" @click="handleContextEdit">Edit</button>
|
|
<button
|
|
v-if="contextMenu.node?.children"
|
|
class="context-item"
|
|
@click="handleContextZoomIn"
|
|
>
|
|
> Open dimension
|
|
</button>
|
|
<button
|
|
v-if="!contextMenu.node?.children"
|
|
class="context-item"
|
|
@click="handleContextAddDimension"
|
|
>
|
|
+ Add dimension
|
|
</button>
|
|
<button class="context-item danger" @click="handleContextDelete">Delete</button>
|
|
</template>
|
|
</div>
|
|
</Transition>
|
|
|
|
</div>
|
|
</template>
|
|
|
|
<style scoped>
|
|
/* -----------------------------------------------------------------------
|
|
Container & canvas
|
|
----------------------------------------------------------------------- */
|
|
.metro-canvas-container {
|
|
position: relative;
|
|
width: 100%;
|
|
height: 100%;
|
|
overflow: hidden;
|
|
background-color: #1a1a2e;
|
|
}
|
|
|
|
.metro-canvas {
|
|
display: block;
|
|
width: 100%;
|
|
height: 100%;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
Depth indicator
|
|
----------------------------------------------------------------------- */
|
|
.depth-indicator {
|
|
position: absolute;
|
|
bottom: 16px;
|
|
left: 16px;
|
|
font-family: 'VT323', monospace;
|
|
font-size: 14px;
|
|
color: #00d2ff;
|
|
background: rgba(22, 33, 62, 0.8);
|
|
border: 1px solid rgba(0, 210, 255, 0.3);
|
|
padding: 4px 10px;
|
|
border-radius: 3px;
|
|
letter-spacing: 0.1em;
|
|
user-select: none;
|
|
display: flex;
|
|
align-items: center;
|
|
gap: 8px;
|
|
}
|
|
|
|
.depth-back {
|
|
color: #e94560;
|
|
cursor: pointer;
|
|
transition: color 0.15s;
|
|
}
|
|
|
|
.depth-back:hover {
|
|
color: #ff8fab;
|
|
text-shadow: 0 0 8px rgba(233, 69, 96, 0.6);
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
Transition progress bar
|
|
----------------------------------------------------------------------- */
|
|
.transition-bar {
|
|
position: absolute;
|
|
bottom: 0;
|
|
left: 0;
|
|
height: 2px;
|
|
background: linear-gradient(90deg, #00d2ff, #e94560);
|
|
transition: width 0.05s linear;
|
|
pointer-events: none;
|
|
box-shadow: 0 0 8px rgba(0, 210, 255, 0.6);
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
Hover tooltip
|
|
----------------------------------------------------------------------- */
|
|
.node-tooltip {
|
|
position: absolute;
|
|
pointer-events: none;
|
|
background: #16213e;
|
|
border: 1px solid #00d2ff;
|
|
border-radius: 4px;
|
|
padding: 8px 12px;
|
|
z-index: 100;
|
|
box-shadow: 0 0 15px rgba(0, 210, 255, 0.2);
|
|
max-width: 250px;
|
|
}
|
|
|
|
.tooltip-title {
|
|
font-family: 'VT323', monospace;
|
|
font-size: 16px;
|
|
color: #00d2ff;
|
|
}
|
|
|
|
.tooltip-desc {
|
|
font-family: 'IBM Plex Mono', monospace;
|
|
font-size: 11px;
|
|
color: #8892b0;
|
|
margin-top: 4px;
|
|
}
|
|
|
|
.tooltip-status {
|
|
font-family: 'VT323', monospace;
|
|
font-size: 13px;
|
|
color: #00ff88;
|
|
margin-top: 4px;
|
|
}
|
|
|
|
.tooltip-hint {
|
|
font-family: 'VT323', monospace;
|
|
font-size: 11px;
|
|
color: #8892b0;
|
|
margin-top: 6px;
|
|
opacity: 0.6;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
Context menu
|
|
----------------------------------------------------------------------- */
|
|
.context-menu {
|
|
position: fixed;
|
|
z-index: 200;
|
|
min-width: 180px;
|
|
background: #0d1b2a;
|
|
border: 1px solid #00d2ff;
|
|
border-radius: 4px;
|
|
box-shadow: 0 0 20px rgba(0, 210, 255, 0.25), inset 0 0 40px rgba(0, 0, 0, 0.4);
|
|
overflow: hidden;
|
|
font-family: 'VT323', monospace;
|
|
}
|
|
|
|
.context-menu-header {
|
|
padding: 6px 12px;
|
|
font-size: 12px;
|
|
color: #00d2ff;
|
|
letter-spacing: 0.15em;
|
|
background: rgba(0, 210, 255, 0.08);
|
|
border-bottom: 1px solid rgba(0, 210, 255, 0.2);
|
|
user-select: none;
|
|
text-overflow: ellipsis;
|
|
overflow: hidden;
|
|
white-space: nowrap;
|
|
}
|
|
|
|
.context-item {
|
|
display: block;
|
|
width: 100%;
|
|
padding: 8px 14px;
|
|
text-align: left;
|
|
background: none;
|
|
border: none;
|
|
color: #e8e8e8;
|
|
font-family: 'VT323', monospace;
|
|
font-size: 15px;
|
|
cursor: pointer;
|
|
letter-spacing: 0.05em;
|
|
transition: background 0.12s, color 0.12s;
|
|
border-bottom: 1px solid rgba(255, 255, 255, 0.04);
|
|
}
|
|
|
|
.context-item:last-child {
|
|
border-bottom: none;
|
|
}
|
|
|
|
.context-item:hover {
|
|
background: rgba(0, 210, 255, 0.12);
|
|
color: #00d2ff;
|
|
}
|
|
|
|
.context-item.danger {
|
|
color: #e94560;
|
|
}
|
|
|
|
.context-item.danger:hover {
|
|
background: rgba(233, 69, 96, 0.12);
|
|
color: #ff8fab;
|
|
}
|
|
|
|
.context-hint {
|
|
padding: 8px 14px;
|
|
color: #8892b0;
|
|
font-family: 'VT323', monospace;
|
|
font-size: 13px;
|
|
opacity: 0.7;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
Transitions
|
|
----------------------------------------------------------------------- */
|
|
.fade-enter-active,
|
|
.fade-leave-active {
|
|
transition: opacity 0.15s;
|
|
}
|
|
|
|
.fade-enter-from,
|
|
.fade-leave-to {
|
|
opacity: 0;
|
|
}
|
|
|
|
.menu-fade-enter-active {
|
|
transition: opacity 0.1s, transform 0.1s;
|
|
}
|
|
|
|
.menu-fade-leave-active {
|
|
transition: opacity 0.08s;
|
|
}
|
|
|
|
.menu-fade-enter-from {
|
|
opacity: 0;
|
|
transform: scale(0.95) translateY(-4px);
|
|
}
|
|
|
|
.menu-fade-leave-to {
|
|
opacity: 0;
|
|
}
|
|
</style>
|