366 lines
18 KiB
TypeScript
366 lines
18 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
||
import { cableFromPins, cableIntoPins } from '../app/lib/logic/cables'
|
||
import { checkCircuit, doublyFedLines } from '../app/lib/logic/check'
|
||
import { compile } from '../app/lib/logic/compile'
|
||
import { pinKindOf, shapeOf } from '../app/lib/logic/geometry'
|
||
import { pinName } from '../app/lib/logic/labels'
|
||
import { createProject, lineForWire, lookup, pruneWires, splitPort, unpackChip } from '../app/lib/logic/ops'
|
||
import { attachPanel, syncPanels } from '../app/lib/logic/panels'
|
||
import { toProject } from '../app/lib/logic/project'
|
||
import { Simulator } from '../app/lib/logic/sim'
|
||
import type { CircuitNode, ComponentDef, Project, Wire } from '../app/lib/logic/types'
|
||
|
||
const w = (id: string, from: [string, string], to: [string, string]): Wire => ({ id, from: { node: from[0], pin: from[1] }, to: { node: to[0], pin: to[1] } })
|
||
|
||
/**
|
||
* The "Mini HDMI" of the connector tests: D0 and D1 out → in, HPD back.
|
||
* Source sends A and B out of its out port and reports HPD; Sink shows the
|
||
* data as X and Y and drives HPD from H. Root places one of each, unwired.
|
||
*/
|
||
function project(): Project {
|
||
const p = createProject({ examples: false })
|
||
p.connectors = [{ id: 'hdmi', name: 'Mini HDMI', color: 'blue', lines: [{ name: 'D0' }, { name: 'D1' }, { name: 'HPD', back: true }] }]
|
||
const source: ComponentDef = {
|
||
id: 'source',
|
||
name: 'Source',
|
||
symbol: 'box',
|
||
nodes: [
|
||
{ id: 'a', kind: 'input', x: 0, y: 0, label: 'A' },
|
||
{ id: 'b', kind: 'input', x: 0, y: 2, label: 'B' },
|
||
{ id: 'tx', kind: 'portout', conn: 'hdmi', x: 20, y: 0, label: 'OUT' },
|
||
{ id: 'hpd', kind: 'output', x: 10, y: 8, label: 'HPD' },
|
||
],
|
||
wires: [w('w1', ['a', 'q'], ['tx', 'l0']), w('w2', ['b', 'q'], ['tx', 'l1']), w('w3', ['tx', 'l2'], ['hpd', 'a'])],
|
||
}
|
||
const sink: ComponentDef = {
|
||
id: 'sink',
|
||
name: 'Sink',
|
||
symbol: 'box',
|
||
nodes: [
|
||
{ id: 'rx', kind: 'portin', conn: 'hdmi', x: 0, y: 0, label: 'IN' },
|
||
{ id: 'x', kind: 'output', x: 20, y: 0, label: 'X' },
|
||
{ id: 'y', kind: 'output', x: 20, y: 2, label: 'Y' },
|
||
{ id: 'h', kind: 'input', x: 10, y: 8, label: 'H' },
|
||
],
|
||
wires: [w('w1', ['rx', 'l0'], ['x', 'a']), w('w2', ['rx', 'l1'], ['y', 'a']), w('w3', ['h', 'q'], ['rx', 'l2'])],
|
||
}
|
||
const root: ComponentDef = {
|
||
id: 'root',
|
||
name: 'Root',
|
||
symbol: 'box',
|
||
nodes: [
|
||
{ id: 'sa', kind: 'input', x: 0, y: 0 },
|
||
{ id: 'sb', kind: 'input', x: 0, y: 2 },
|
||
{ id: 'sh', kind: 'input', x: 0, y: 8 },
|
||
{ id: 'src', kind: 'chip', chip: 'source', x: 6, y: 0 },
|
||
{ id: 'snk', kind: 'chip', chip: 'sink', x: 30, y: 0 },
|
||
{ id: 'lamp', kind: 'lamp', x: 50, y: 0 },
|
||
],
|
||
wires: [w('r1', ['sa', 'q'], ['src', 'a']), w('r2', ['sb', 'q'], ['src', 'b']), w('r3', ['sh', 'q'], ['snk', 'h'])],
|
||
}
|
||
p.components.push(source, sink, root)
|
||
return p
|
||
}
|
||
|
||
const node = (p: Project, def: string, id: string) => p.components.find(d => d.id === def)!.nodes.find(n => n.id === id)!
|
||
const root = (p: Project) => p.components.find(d => d.id === 'root')!
|
||
|
||
function run(p: Project, on: Record<string, boolean>) {
|
||
const s = new Simulator(compile(lookup(p), 'root'))
|
||
for (const [k, v] of Object.entries(on)) s.setSource(k, v)
|
||
s.run()
|
||
return s
|
||
}
|
||
|
||
describe('ports on a component box', () => {
|
||
it('sit at the very top of their side, above the single pins', () => {
|
||
const p = project()
|
||
// More single pins than before, so a port at the bottom would show.
|
||
node(p, 'sink', 'h').y = -4
|
||
p.components.find(d => d.id === 'sink')!.nodes.push({ id: 'k', kind: 'input', x: 10, y: 10, label: 'K' })
|
||
const get = lookup(p)
|
||
const snk = shapeOf({ id: 'n', kind: 'chip', chip: 'sink', x: 0, y: 0 }, get)
|
||
expect(snk.inputs.map(i => [i.key, i.dy])).toEqual([['rx', 0], ['h', 1], ['k', 2]])
|
||
const src = shapeOf({ id: 'n', kind: 'chip', chip: 'source', x: 0, y: 0 }, get)
|
||
expect(src.outputs.map(o => [o.key, o.dx, o.dy])).toEqual([['tx', src.body.w, 0], ['hpd', src.body.w, 1]])
|
||
})
|
||
|
||
it('also at the top of a box drawn by hand', () => {
|
||
const p = project()
|
||
const sink = p.components.find(d => d.id === 'sink')!
|
||
sink.design = { w: 6, h: 3, pinAt: { h: 0, x: 2 } }
|
||
const s = shapeOf({ id: 'n', kind: 'chip', chip: 'sink', x: 0, y: 0 }, lookup(p))
|
||
expect(s.inputs.map(i => [i.key, i.dy])).toEqual([['rx', 0], ['h', 1]])
|
||
expect(s.outputs.map(o => [o.key, o.dx, o.dy])).toEqual([['x', 6, 2], ['y', 6, 3]])
|
||
})
|
||
|
||
it('split, a port shows a pin per line right below its socket, each facing out of its side', () => {
|
||
const p = project()
|
||
const get = lookup(p)
|
||
const snk = shapeOf({ id: 'n', kind: 'chip', chip: 'sink', x: 0, y: 0, splitPorts: ['rx'] }, get)
|
||
// In port on the left: D0 and D1 come in (inputs), HPD goes back out (an output on the left).
|
||
expect(snk.inputs.map(i => [i.key, i.label, i.dx, i.dy, i.face])).toEqual([
|
||
['rx', 'IN', 0, 0, undefined],
|
||
['rx.l0', 'D0', 0, 1, -1],
|
||
['rx.l1', 'D1', 0, 2, -1],
|
||
['h', 'H', 0, 4, undefined],
|
||
])
|
||
expect(snk.outputs.find(o => o.key === 'rx.l2')).toMatchObject({ label: 'HPD', dx: 0, dy: 3, face: -1, port: 'rx' })
|
||
// Out port on the right: D0 and D1 go out, HPD comes back in (an input on the right).
|
||
const src = shapeOf({ id: 'n', kind: 'chip', chip: 'source', x: 0, y: 0, splitPorts: ['tx'] }, get)
|
||
const right = src.body.w
|
||
expect(src.outputs.map(o => [o.key, o.dx, o.dy, o.face])).toEqual([
|
||
['tx', right, 0, undefined],
|
||
['tx.l0', right, 1, 1],
|
||
['tx.l1', right, 2, 1],
|
||
['hpd', right, 4, undefined],
|
||
])
|
||
expect(src.inputs.find(i => i.key === 'tx.l2')).toMatchObject({ label: 'HPD', dx: right, dy: 3, face: 1 })
|
||
// Lines take single wires; the socket still takes the cable.
|
||
expect(pinKindOf(snk.inputs[1]!)).toBe('')
|
||
expect(pinKindOf(snk.inputs[0]!)).toBe('c:hdmi')
|
||
})
|
||
|
||
it('split on a box drawn by hand, the lines follow the socket and push the pins below down', () => {
|
||
const p = project()
|
||
p.components.find(d => d.id === 'sink')!.design = { w: 6, h: 3, pinAt: { h: 1 } }
|
||
const s = shapeOf({ id: 'n', kind: 'chip', chip: 'sink', x: 0, y: 0, splitPorts: ['rx'] }, lookup(p))
|
||
expect(s.inputs.map(i => [i.key, i.dy])).toEqual([['rx', 0], ['rx.l0', 1], ['rx.l1', 2], ['h', 4]])
|
||
expect(s.outputs.find(o => o.key === 'rx.l2')).toMatchObject({ dx: 0, dy: 3 })
|
||
})
|
||
|
||
it('a line wired from outside drives the inside, and a back line brings the inside out', () => {
|
||
const p = project()
|
||
node(p, 'root', 'snk').splitPorts = ['rx']
|
||
root(p).wires.push(w('d0', ['sa', 'q'], ['snk', 'rx.l0']), w('hp', ['snk', 'rx.l2'], ['lamp', 'a']))
|
||
for (const [a, h] of [[0, 0], [1, 0], [0, 1], [1, 1]] as const) {
|
||
const s = run(p, { sa: !!a, sh: !!h })
|
||
expect([s.pin('snk', 'x'), s.pin('snk', 'rx.l2'), s.pin('lamp', 'q')]).toEqual([a, h, h])
|
||
}
|
||
})
|
||
|
||
it('an out port split the same way: its lines leave on the right, the back line comes in there', () => {
|
||
const p = project()
|
||
node(p, 'root', 'src').splitPorts = ['tx']
|
||
root(p).wires.push(w('d1', ['src', 'tx.l1'], ['lamp', 'a']), w('hp', ['sh', 'q'], ['src', 'tx.l2']))
|
||
for (const [b, h] of [[0, 1], [1, 0], [1, 1]] as const) {
|
||
const s = run(p, { sb: !!b, sh: !!h })
|
||
expect([s.pin('lamp', 'q'), s.pin('src', 'hpd')]).toEqual([b, h])
|
||
}
|
||
})
|
||
|
||
it('a cable on the socket and wires on the lines work together', () => {
|
||
const p = project()
|
||
node(p, 'root', 'snk').splitPorts = ['rx']
|
||
root(p).wires.push(w('cable', ['src', 'tx'], ['snk', 'rx']), w('hp', ['snk', 'rx.l2'], ['lamp', 'a']))
|
||
const s = run(p, { sa: true, sb: false, sh: true })
|
||
// The cable still carries every line; the line pins show what it carries.
|
||
expect([s.pin('snk', 'x'), s.pin('snk', 'y'), s.pin('src', 'hpd')]).toEqual([1, 0, 1])
|
||
expect([s.pin('snk', 'rx.l0'), s.pin('snk', 'rx.l1'), s.pin('lamp', 'q')]).toEqual([1, 0, 1])
|
||
expect(doublyFedLines(root(p), node(p, 'root', 'snk'), lookup(p))).toEqual([])
|
||
// A wire into a line the cable feeds as well: both drive it, and the check says so.
|
||
root(p).wires.push(w('d0', ['sb', 'q'], ['snk', 'rx.l0']))
|
||
expect(doublyFedLines(root(p), node(p, 'root', 'snk'), lookup(p))).toEqual(['rx.l0'])
|
||
expect(checkCircuit(root(p), lookup(p)).some(i => i.level === 'error' && i.text.includes('D0'))).toBe(true)
|
||
})
|
||
|
||
it('passes split lines through a component that offers an inner part’s port as its own', () => {
|
||
const p = project()
|
||
p.components.push({
|
||
id: 'box',
|
||
name: 'Box',
|
||
symbol: 'box',
|
||
nodes: [
|
||
{ id: 'i', kind: 'input', x: 0, y: 0, label: 'I' },
|
||
{ id: 'inner', kind: 'chip', chip: 'source', x: 6, y: 0 },
|
||
{ id: 'p2', kind: 'portout', conn: 'hdmi', x: 30, y: 0 },
|
||
],
|
||
wires: [w('b1', ['i', 'q'], ['inner', 'a']), w('b2', ['inner', 'tx'], ['p2', 'bus'])],
|
||
})
|
||
root(p).nodes.push({ id: 'bx', kind: 'chip', chip: 'box', x: 6, y: 20, splitPorts: ['p2'] })
|
||
root(p).wires.push(w('r9', ['sa', 'q'], ['bx', 'i']), w('l0', ['bx', 'p2.l0'], ['lamp', 'a']))
|
||
expect(run(p, { sa: true }).pin('lamp', 'q')).toBe(1)
|
||
expect(run(p, { sa: false }).pin('lamp', 'q')).toBe(0)
|
||
})
|
||
|
||
it('joining a port again removes the wires on its lines and keeps the cable', () => {
|
||
const p = project()
|
||
const r = root(p)
|
||
expect(splitPort(p, r, 'snk', 'rx', true)).toBe(0)
|
||
expect(node(p, 'root', 'snk').splitPorts).toEqual(['rx'])
|
||
r.wires.push(w('cable', ['src', 'tx'], ['snk', 'rx']), w('d0', ['sa', 'q'], ['snk', 'rx.l0']), w('hp', ['snk', 'rx.l2'], ['lamp', 'a']))
|
||
expect(pruneWires(p)).toBe(false)
|
||
expect(splitPort(p, r, 'snk', 'rx', false)).toBe(2)
|
||
expect(node(p, 'root', 'snk').splitPorts).toBeUndefined()
|
||
expect(r.wires.map(x => x.id)).toEqual(['r1', 'r2', 'r3', 'cable'])
|
||
// No port of that name: nothing changes.
|
||
expect(splitPort(p, r, 'snk', 'nope', true)).toBe(0)
|
||
expect(node(p, 'root', 'snk').splitPorts).toBeUndefined()
|
||
})
|
||
|
||
it('a single wire dropped on a socket takes the first free line that runs its way', () => {
|
||
const p = project()
|
||
const r = root(p)
|
||
// Into the sink's in port: D0, then D1; from it: HPD.
|
||
expect(lineForWire(p, r, 'snk', 'rx', true)).toBe('rx.l0')
|
||
expect(lineForWire(p, r, 'snk', 'rx', false)).toBe('rx.l2')
|
||
r.wires.push(w('d0', ['sa', 'q'], ['snk', 'rx.l0']))
|
||
expect(lineForWire(p, r, 'snk', 'rx', true)).toBe('rx.l1')
|
||
r.wires.push(w('d1', ['sb', 'q'], ['snk', 'rx.l1']))
|
||
expect(lineForWire(p, r, 'snk', 'rx', true)).toBeNull()
|
||
// A line coming out can feed another wire.
|
||
r.wires.push(w('hp', ['snk', 'rx.l2'], ['lamp', 'a']))
|
||
expect(lineForWire(p, r, 'snk', 'rx', false)).toBe('rx.l2')
|
||
// The source's out port: its back line goes in, D0 comes out first.
|
||
expect(lineForWire(p, r, 'src', 'tx', true)).toBe('tx.l2')
|
||
expect(lineForWire(p, r, 'src', 'tx', false)).toBe('tx.l0')
|
||
expect(lineForWire(p, r, 'src', 'nope', true)).toBeNull()
|
||
})
|
||
|
||
it('cleans up wires on lines whose port is no longer split', () => {
|
||
const p = project()
|
||
node(p, 'root', 'snk').splitPorts = ['rx']
|
||
root(p).wires.push(w('d0', ['sa', 'q'], ['snk', 'rx.l0']))
|
||
expect(pruneWires(p)).toBe(false)
|
||
delete node(p, 'root', 'snk').splitPorts
|
||
expect(pruneWires(p)).toBe(true)
|
||
expect(root(p).wires.some(x => x.id === 'd0')).toBe(false)
|
||
})
|
||
|
||
it('a typed cable never plugs into a line, a single wire never into a socket', () => {
|
||
const p = project()
|
||
node(p, 'root', 'snk').splitPorts = ['rx']
|
||
root(p).wires.push(w('bad1', ['src', 'tx'], ['snk', 'rx.l0']), w('bad2', ['sa', 'q'], ['snk', 'rx']))
|
||
expect(pruneWires(p)).toBe(true)
|
||
expect(root(p).wires.map(x => x.id)).toEqual(['r1', 'r2', 'r3'])
|
||
})
|
||
|
||
it('names a line pin after its line, keeps the setting through loading and leaves line pins off docked panels', () => {
|
||
const p = project()
|
||
const snk = node(p, 'root', 'snk')
|
||
snk.splitPorts = ['rx']
|
||
expect(pinName(snk, 'rx.l1', lookup(p))).toBe('D1')
|
||
const data = JSON.parse(JSON.stringify(p))
|
||
data.components.find((d: ComponentDef) => d.id === 'root').nodes.find((n: CircuitNode) => n.id === 'src').splitPorts = 'tx'
|
||
const back = toProject(data)
|
||
expect(node(back, 'root', 'snk').splitPorts).toEqual(['rx'])
|
||
expect(node(back, 'root', 'src').splitPorts).toBeUndefined()
|
||
// A docked input panel gets a switch for H only: the socket and the lines are the cable's.
|
||
root(p).wires = root(p).wires.filter(x => x.id !== 'r3')
|
||
const panel = attachPanel(p, root(p), 'snk')!
|
||
expect(panel.rows!.map(r => r.id)).toEqual(['h'])
|
||
})
|
||
|
||
it('with a cable in the socket, a dropped wire takes no line going in: the cable feeds those', () => {
|
||
const p = project()
|
||
const r = root(p)
|
||
r.wires.push(w('cable', ['src', 'tx'], ['snk', 'rx']))
|
||
// Into the sink's in port: D0 and D1 come through the cable. HPD can still be read.
|
||
expect(lineForWire(p, r, 'snk', 'rx', true)).toBeNull()
|
||
expect(lineForWire(p, r, 'snk', 'rx', false)).toBe('rx.l2')
|
||
// The source's out port: HPD comes back through the cable, D0 can still be read.
|
||
expect(lineForWire(p, r, 'src', 'tx', true)).toBeNull()
|
||
expect(lineForWire(p, r, 'src', 'tx', false)).toBe('tx.l0')
|
||
})
|
||
|
||
it('a line going in with neither a wire nor a cable is an open input', () => {
|
||
const p = project()
|
||
node(p, 'root', 'snk').splitPorts = ['rx']
|
||
root(p).wires.push(w('d0', ['sa', 'q'], ['snk', 'rx.l0']))
|
||
expect(checkCircuit(root(p), lookup(p)).some(i => i.level === 'warn' && i.text === 'Sink: D1 not connected (reads 0)')).toBe(true)
|
||
// A cable in the socket feeds D1.
|
||
root(p).wires = root(p).wires.filter(x => x.id !== 'd0')
|
||
root(p).wires.push(w('cable', ['src', 'tx'], ['snk', 'rx']))
|
||
expect(checkCircuit(root(p), lookup(p)).some(i => i.text.includes('not connected'))).toBe(false)
|
||
})
|
||
|
||
it('splitting or joining a port leaves the pins of the other side where they are', () => {
|
||
const p = project()
|
||
const get = lookup(p)
|
||
for (const design of [undefined, { w: 6, h: 3 }]) {
|
||
p.components.find(d => d.id === 'source')!.design = design
|
||
const rows = (splitPorts?: string[]) => shapeOf({ id: 'n', kind: 'chip', chip: 'source', x: 0, y: 0, splitPorts }, get).inputs.filter(i => !i.port).map(i => [i.key, i.dy])
|
||
expect(rows(['tx'])).toEqual(rows())
|
||
}
|
||
// A side of single pins only is still centred when nothing is split.
|
||
p.components.find(d => d.id === 'source')!.design = undefined
|
||
p.components.find(d => d.id === 'source')!.nodes.push({ id: 'z', kind: 'output', x: 10, y: 10, label: 'Z' }, { id: 'z2', kind: 'output', x: 10, y: 12, label: 'Z2' })
|
||
expect(shapeOf({ id: 'n', kind: 'chip', chip: 'source', x: 0, y: 0 }, get).inputs.map(i => [i.key, i.dy])).toEqual([['a', 1], ['b', 2]])
|
||
})
|
||
|
||
it('lists the pins of the usual edge first, so a wire dropped on the box takes those', () => {
|
||
const p = project()
|
||
const get = lookup(p)
|
||
const snk = shapeOf({ id: 'n', kind: 'chip', chip: 'sink', x: 0, y: 0, splitPorts: ['rx'] }, get)
|
||
expect(snk.outputs.map(o => o.key)).toEqual(['x', 'y', 'rx.l2'])
|
||
const src = shapeOf({ id: 'n', kind: 'chip', chip: 'source', x: 0, y: 0, splitPorts: ['tx'] }, get)
|
||
expect(src.inputs.map(i => i.key)).toEqual(['a', 'b', 'tx.l2'])
|
||
})
|
||
|
||
it('a cable onto split lines only takes those on their usual edge, so its end never sits in the box', () => {
|
||
const p = project()
|
||
p.connectors![0]!.lines = [{ name: 'D0' }, { name: 'D1' }, { name: 'RX0', back: true }, { name: 'RX1', back: true }]
|
||
const r = root(p)
|
||
const get = lookup(p)
|
||
node(p, 'root', 'src').splitPorts = ['tx']
|
||
node(p, 'root', 'snk').splitPorts = ['rx']
|
||
// RX0 and RX1 run back: into the source on its right edge, out of the sink on its left.
|
||
expect(cableIntoPins(r, 'src', ['tx.l2', 'tx.l3'], get).ok).toBe(false)
|
||
expect(cableFromPins(r, 'snk', ['rx.l2', 'rx.l3'], get).ok).toBe(false)
|
||
// D0 and D1 leave the source on the right and enter the sink on the left: there a cable fits.
|
||
const src = node(p, 'root', 'src')
|
||
const out = cableFromPins(r, 'src', ['tx.l0', 'tx.l1'], get)
|
||
expect(out.ok && out.bundle.x).toBe(src.x + shapeOf(src, get).body.w)
|
||
const into = cableIntoPins(r, 'snk', ['rx.l0', 'rx.l1'], get)
|
||
expect(into.ok && into.split.x).toBe(node(p, 'root', 'snk').x - 1)
|
||
})
|
||
|
||
it('unpacking joins wires on split lines to the parts inside', () => {
|
||
const p = project()
|
||
const r = root(p)
|
||
node(p, 'root', 'snk').splitPorts = ['rx']
|
||
r.nodes.push({ id: 'lamp2', kind: 'lamp', x: 50, y: 4 })
|
||
r.wires.push(w('d0', ['sa', 'q'], ['snk', 'rx.l0']), w('xl', ['snk', 'x'], ['lamp', 'a']), w('hp', ['snk', 'rx.l2'], ['lamp2', 'a']))
|
||
const res = unpackChip(p, 'root', 'snk')
|
||
expect(res.ok && res.dropped).toBe(0)
|
||
for (const [a, h] of [[0, 1], [1, 0]] as const) {
|
||
const s = run(p, { sa: !!a, sh: !!h })
|
||
expect([s.pin('lamp', 'q'), s.pin('lamp2', 'q')]).toEqual([a, h])
|
||
}
|
||
})
|
||
|
||
it('unpacking says how many wires on lines had nowhere to go', () => {
|
||
const p = project()
|
||
p.components.push({
|
||
id: 'box',
|
||
name: 'Box',
|
||
symbol: 'box',
|
||
nodes: [
|
||
{ id: 'inner', kind: 'chip', chip: 'source', x: 6, y: 0 },
|
||
{ id: 'p2', kind: 'portout', conn: 'hdmi', x: 30, y: 0 },
|
||
],
|
||
wires: [w('b2', ['inner', 'tx'], ['p2', 'bus'])],
|
||
})
|
||
// D0 of the box comes from a part inside through a cable: no single wire inside to join it to.
|
||
root(p).nodes.push({ id: 'bx', kind: 'chip', chip: 'box', x: 6, y: 20, splitPorts: ['p2'] })
|
||
root(p).wires.push(w('l0', ['bx', 'p2.l0'], ['lamp', 'a']))
|
||
const res = unpackChip(p, 'root', 'bx')
|
||
expect(res.ok && res.dropped).toBe(1)
|
||
})
|
||
|
||
it('a docked panel made before ports moved to the top loses its row for the socket and lines up again', () => {
|
||
const p = project()
|
||
const r = root(p)
|
||
r.wires = r.wires.filter(x => x.id !== 'r3')
|
||
// As docked by earlier releases: a row for H and one for the socket below it, the port at the bottom.
|
||
r.nodes.push({ id: 'pan', kind: 'panel', x: 24, y: 0, attach: 'snk', rows: [{ id: 'h', type: 'switch', dy: 0 }, { id: 'rx', type: 'switch', dy: 1 }] })
|
||
r.wires.push(w('ph', ['pan', 'h'], ['snk', 'h']))
|
||
syncPanels(p)
|
||
pruneWires(p)
|
||
const pan = node(p, 'root', 'pan')
|
||
expect(pan.rows!.map(x => x.id)).toEqual(['h'])
|
||
const h = shapeOf(node(p, 'root', 'snk'), lookup(p)).inputs.find(i => i.key === 'h')!
|
||
expect(pan.y).toBe(node(p, 'root', 'snk').y + h.dy)
|
||
})
|
||
})
|