pict-section-flow 1.1.0 → 1.3.0

package/test/Layout_tests.js

@@ -6,6 +6,8 @@ const libLayoutService = require('../source/services/PictService-Flow-Layout.js'
 
 const libLayoutCustom           = require('../source/providers/layouts/Layout-Custom.js');
 const libLayoutLayered          = require('../source/providers/layouts/Layout-Layered.js');
+const libLayoutStaggered        = require('../source/providers/layouts/Layout-Staggered.js');
+const libLayoutRank             = require('../source/providers/layouts/Layout-Rank.js');
 const libLayoutForcedFromCenter = require('../source/providers/layouts/Layout-ForcedFromCenter.js');
 const libLayoutGrid             = require('../source/providers/layouts/Layout-Grid.js');
 const libLayoutCircular         = require('../source/providers/layouts/Layout-Circular.js');
@@ -86,15 +88,15 @@ suite
 
 				test
 				(
-					'should register all seven built-in algorithms by default',
+					'should register all eight built-in algorithms by default',
 					function (fDone)
 					{
 						let tmpNames = _LayoutService.getAlgorithmNames();
 						libExpect(tmpNames).to.include.members([
-							'Custom', 'Layered', 'ForcedFromCenter',
+							'Custom', 'Layered', 'Staggered', 'ForcedFromCenter',
 							'Grid', 'Circular', 'Tabular', 'Columnar'
 						]);
-						libExpect(tmpNames.length).to.equal(7);
+						libExpect(tmpNames.length).to.equal(8);
 						fDone();
 					}
 				);
@@ -184,9 +186,10 @@ suite
 					function (fDone)
 					{
 						let tmpAll = _LayoutService.listAlgorithms();
-						libExpect(tmpAll.length).to.equal(7);
+						libExpect(tmpAll.length).to.equal(8);
 						let tmpNames = tmpAll.map((pA) => pA.Name);
 						libExpect(tmpNames).to.include('Custom');
+						libExpect(tmpNames).to.include('Staggered');
 						libExpect(tmpNames).to.include('ForcedFromCenter');
 						fDone();
 					}
@@ -315,6 +318,207 @@ suite
 						fDone();
 					}
 				);
+
+				test
+				(
+					'a back-edge cycle does NOT collapse into one column (regression)',
+					function (fDone)
+					{
+						// n0 -> n1 -> n2 -> n3 -> n4 with a back-edge n4 -> n1.
+						// Plain Kahn's would place n0, then dump n1..n4 into a single
+						// trailing layer (one tall column). The cycle-tolerant ranker
+						// must spread them across columns instead.
+						let tmpNodes = makeNodes(5);
+						let tmpConns = makeChain(5);
+						tmpConns.push({ Hash: 'c-back', SourceNodeHash: 'n-4', TargetNodeHash: 'n-1' });
+
+						libLayoutLayered.Apply(tmpNodes, tmpConns, libLayoutLayered.DefaultParameters);
+
+						let tmpColumns = {};
+						let tmpMaxPerColumn = 0;
+						for (let i = 0; i < tmpNodes.length; i++)
+						{
+							let tmpX = tmpNodes[i].X;
+							tmpColumns[tmpX] = (tmpColumns[tmpX] || 0) + 1;
+							tmpMaxPerColumn = Math.max(tmpMaxPerColumn, tmpColumns[tmpX]);
+						}
+						// Five distinct columns, one node each — no tower.
+						libExpect(Object.keys(tmpColumns).length).to.equal(5);
+						libExpect(tmpMaxPerColumn).to.equal(1);
+						fDone();
+					}
+				);
+
+				test
+				(
+					'a self-loop does not strand a node in a trailing column',
+					function (fDone)
+					{
+						// n0 -> n1 -> n2 with a self-loop on n1.
+						let tmpNodes = makeNodes(3);
+						let tmpConns = makeChain(3);
+						tmpConns.push({ Hash: 'c-self', SourceNodeHash: 'n-1', TargetNodeHash: 'n-1' });
+
+						libLayoutLayered.Apply(tmpNodes, tmpConns, libLayoutLayered.DefaultParameters);
+
+						// Clean chain: three columns left to right, one node each.
+						libExpect(tmpNodes[0].X).to.be.below(tmpNodes[1].X);
+						libExpect(tmpNodes[1].X).to.be.below(tmpNodes[2].X);
+						fDone();
+					}
+				);
+			}
+		);
+
+		// ── Rank (shared ranker) ──────────────────────────────────────
+
+		suite
+		(
+			'Layout-Rank ranker',
+			function ()
+			{
+				test
+				(
+					'a chain ranks one node per rank, in order',
+					function (fDone)
+					{
+						let tmpNodes = makeNodes(4);
+						let tmpRanks = libLayoutRank.toRanks(tmpNodes, makeChain(4));
+						libExpect(tmpRanks.length).to.equal(4);
+						libExpect(tmpRanks[0]).to.deep.equal(['n-0']);
+						libExpect(tmpRanks[3]).to.deep.equal(['n-3']);
+						fDone();
+					}
+				);
+
+				test
+				(
+					'unconnected nodes share the first rank',
+					function (fDone)
+					{
+						let tmpNodes = makeNodes(3);
+						let tmpRanks = libLayoutRank.toRanks(tmpNodes, []);
+						libExpect(tmpRanks.length).to.equal(1);
+						libExpect(tmpRanks[0].length).to.equal(3);
+						fDone();
+					}
+				);
+
+				test
+				(
+					'toOrder visits every node exactly once even with a cycle',
+					function (fDone)
+					{
+						let tmpNodes = makeNodes(5);
+						let tmpConns = makeChain(5);
+						tmpConns.push({ Hash: 'c-back', SourceNodeHash: 'n-4', TargetNodeHash: 'n-1' });
+						let tmpOrder = libLayoutRank.toOrder(tmpNodes, tmpConns);
+						libExpect(tmpOrder.length).to.equal(5);
+						let tmpSeen = {};
+						for (let i = 0; i < tmpOrder.length; i++) tmpSeen[tmpOrder[i]] = true;
+						libExpect(Object.keys(tmpSeen).length).to.equal(5);
+						fDone();
+					}
+				);
+
+				test
+				(
+					'empty input returns an empty rank list',
+					function (fDone)
+					{
+						libExpect(libLayoutRank.toRanks([], [])).to.deep.equal([]);
+						libExpect(libLayoutRank.toOrder(null, null)).to.deep.equal([]);
+						fDone();
+					}
+				);
+			}
+		);
+
+		// ── Staggered ─────────────────────────────────────────────────
+
+		suite
+		(
+			'Staggered algorithm',
+			function ()
+			{
+				test
+				(
+					'two rows zigzag: X strictly increases, Y alternates',
+					function (fDone)
+					{
+						let tmpNodes = makeNodes(4);
+						let tmpConns = makeChain(4);
+						libLayoutStaggered.Apply(tmpNodes, tmpConns, { Rows: 2, ColumnSpacing: 80, RowOffset: 150, StartX: 0, StartY: 0 });
+
+						// Topological order is n0..n3; column pitch = 180 + 80 = 260.
+						libExpect(tmpNodes[0].X).to.equal(0);
+						libExpect(tmpNodes[1].X).to.equal(260);
+						libExpect(tmpNodes[2].X).to.equal(520);
+						libExpect(tmpNodes[3].X).to.equal(780);
+						// Rows=2 → row pattern 0,1,0,1 → Y 0,150,0,150.
+						libExpect(tmpNodes[0].Y).to.equal(0);
+						libExpect(tmpNodes[1].Y).to.equal(150);
+						libExpect(tmpNodes[2].Y).to.equal(0);
+						libExpect(tmpNodes[3].Y).to.equal(150);
+						fDone();
+					}
+				);
+
+				test
+				(
+					'three rows make a triangle-wave stairstep (down then up)',
+					function (fDone)
+					{
+						let tmpNodes = makeNodes(6);
+						let tmpConns = makeChain(6);
+						libLayoutStaggered.Apply(tmpNodes, tmpConns, { Rows: 3, RowOffset: 100, StartX: 0, StartY: 0 });
+
+						// period = 4 → row phases 0,1,2,1,0,1 → Y 0,100,200,100,0,100.
+						let tmpRows = tmpNodes.map((pN) => pN.Y / 100);
+						libExpect(tmpRows).to.deep.equal([0, 1, 2, 1, 0, 1]);
+						fDone();
+					}
+				);
+
+				test
+				(
+					'column pitch follows the widest node',
+					function (fDone)
+					{
+						let tmpNodes = makeNodes(3);
+						tmpNodes[1].Width = 400; // widest
+						libLayoutStaggered.Apply(tmpNodes, makeChain(3), { ColumnSpacing: 50, StartX: 0 });
+						// pitch = 400 + 50 = 450
+						libExpect(tmpNodes[1].X).to.equal(450);
+						libExpect(tmpNodes[2].X).to.equal(900);
+						fDone();
+					}
+				);
+
+				test
+				(
+					'Rows=1 places every node on a single row',
+					function (fDone)
+					{
+						let tmpNodes = makeNodes(4);
+						libLayoutStaggered.Apply(tmpNodes, makeChain(4), { Rows: 1, StartY: 42 });
+						for (let i = 0; i < tmpNodes.length; i++)
+						{
+							libExpect(tmpNodes[i].Y).to.equal(42);
+						}
+						fDone();
+					}
+				);
+
+				test
+				(
+					'empty node list does not throw',
+					function (fDone)
+					{
+						libExpect(function () { libLayoutStaggered.Apply([], [], {}); }).to.not.throw();
+						fDone();
+					}
+				);
 			}
 		);
 

package/test/NodeView_tests.js

@@ -0,0 +1,66 @@
+const libChai = require('chai');
+const libExpect = libChai.expect;
+
+const libPictViewFlowNode = require('../source/views/PictView-Flow-Node.js');
+
+suite('PictView-Flow-Node',
+function ()
+{
+	// The title-bar bottom strip squares off the title bar's lower corners. The regression it guards
+	// against: a corner radius larger than the title bar made the strip taller than the whole title
+	// bar, so it painted over the rounded TOP corners and the card read as square on top (only the
+	// bottom rounded). See titleBarBottomStripHeight.
+	suite('titleBarBottomStripHeight',
+	function ()
+	{
+		test('never exceeds half the title bar height, even for a capsule radius',
+		function ()
+		{
+			// radius 24 on a 22px title bar must not produce a 24px strip (which would cover the top)
+			libExpect(libPictViewFlowNode.titleBarBottomStripHeight(24, 22)).to.equal(11);
+			libExpect(libPictViewFlowNode.titleBarBottomStripHeight(100, 30)).to.equal(15);
+		});
+
+		test('covers small radii with the 8px floor',
+		function ()
+		{
+			libExpect(libPictViewFlowNode.titleBarBottomStripHeight(5, 22)).to.equal(8);
+			libExpect(libPictViewFlowNode.titleBarBottomStripHeight(0, 22)).to.equal(8);
+		});
+
+		test('treats a null/absent radius as no override (8px floor)',
+		function ()
+		{
+			libExpect(libPictViewFlowNode.titleBarBottomStripHeight(null, 22)).to.equal(8);
+			libExpect(libPictViewFlowNode.titleBarBottomStripHeight(undefined, 22)).to.equal(8);
+		});
+
+		test('the strip is always at most the title bar height for any radius',
+		function ()
+		{
+			let tmpTitleBarHeight = 22;
+			for (let tmpRadius = 0; tmpRadius <= 60; tmpRadius++)
+			{
+				let tmpStrip = libPictViewFlowNode.titleBarBottomStripHeight(tmpRadius, tmpTitleBarHeight);
+				libExpect(tmpStrip).to.be.at.most(Math.floor(tmpTitleBarHeight / 2));
+			}
+		});
+	});
+
+	suite('nodeTransform',
+	function ()
+	{
+		test('a zero / absent rotation is a plain position translate',
+		function ()
+		{
+			libExpect(libPictViewFlowNode.nodeTransform(40, 60, 0, 100, 80)).to.equal('translate(40, 60)');
+			libExpect(libPictViewFlowNode.nodeTransform(40, 60, null, 100, 80)).to.equal('translate(40, 60)');
+		});
+
+		test('a non-zero rotation rotates about the node center',
+		function ()
+		{
+			libExpect(libPictViewFlowNode.nodeTransform(40, 60, 15, 100, 80)).to.equal('translate(40, 60) rotate(15 50 40)');
+		});
+	});
+});

package/test/SelectionManager_tests.js

@@ -0,0 +1,185 @@
+const libFable = require('fable');
+const libChai = require('chai');
+const libExpect = libChai.expect;
+
+const libSelectionManager = require('../source/services/PictService-Flow-SelectionManager.js');
+
+// A minimal FlowView stand-in: just the surface the selection manager touches.
+function makeMockFlowView(pNodes)
+{
+	let tmpFired = [];
+	let tmpRemoved = [];
+	return {
+		_FlowData:
+		{
+			Nodes: pNodes.slice(),
+			Connections: [],
+			OpenPanels: [],
+			ViewState: { SelectedNodeHash: null, SelectedNodeHashes: [], SelectedConnectionHash: null, SelectedTetherHash: null }
+		},
+		renderFlow: function () { this._rendered = (this._rendered || 0) + 1; },
+		removeNode: function (pHash) { tmpRemoved.push(pHash); this._FlowData.Nodes = this._FlowData.Nodes.filter((n) => n.Hash !== pHash); return true; },
+		removeConnection: function (pHash) { tmpRemoved.push('conn:' + pHash); return true; },
+		_EventHandlerProvider: { fireEvent: function (pName, pPayload) { tmpFired.push({ Name: pName, Payload: pPayload }); } },
+		_firedEvents: tmpFired,
+		_removed: tmpRemoved
+	};
+}
+
+function makeManager(pFable, pNodes)
+{
+	let tmpFV = makeMockFlowView(pNodes);
+	let tmpSM = new libSelectionManager(pFable, { FlowView: tmpFV }, 'SM-Test');
+	return { sm: tmpSM, fv: tmpFV, vs: tmpFV._FlowData.ViewState };
+}
+
+suite('PictService-Flow-SelectionManager',
+function ()
+{
+	let _Fable;
+	let _Nodes;
+	setup(function ()
+	{
+		_Fable = new libFable({});
+		_Nodes = [ { Hash: 'n1', X: 0, Y: 0, Width: 100, Height: 80 }, { Hash: 'n2', X: 200, Y: 0, Width: 100, Height: 80 }, { Hash: 'n3', X: 400, Y: 0, Width: 100, Height: 80 } ];
+	});
+
+	suite('single selection keeps the set in lockstep',
+	function ()
+	{
+		test('selectNode sets the primary and a one-element set',
+		function ()
+		{
+			let tmp = makeManager(_Fable, _Nodes);
+			tmp.sm.selectNode('n2');
+			libExpect(tmp.vs.SelectedNodeHash).to.equal('n2');
+			libExpect(tmp.vs.SelectedNodeHashes).to.deep.equal(['n2']);
+		});
+
+		test('selectNode(null) clears both the primary and the set',
+		function ()
+		{
+			let tmp = makeManager(_Fable, _Nodes);
+			tmp.sm.selectNode('n2');
+			tmp.sm.selectNode(null);
+			libExpect(tmp.vs.SelectedNodeHash).to.equal(null);
+			libExpect(tmp.vs.SelectedNodeHashes).to.deep.equal([]);
+		});
+	});
+
+	suite('toggleNodeSelection',
+	function ()
+	{
+		test('adds a node, then a second, then removes the first',
+		function ()
+		{
+			let tmp = makeManager(_Fable, _Nodes);
+			tmp.sm.toggleNodeSelection('n1');
+			libExpect(tmp.vs.SelectedNodeHashes).to.deep.equal(['n1']);
+			libExpect(tmp.vs.SelectedNodeHash).to.equal('n1');
+
+			tmp.sm.toggleNodeSelection('n3');
+			libExpect(tmp.vs.SelectedNodeHashes).to.deep.equal(['n1', 'n3']);
+			libExpect(tmp.vs.SelectedNodeHash).to.equal('n3');
+
+			tmp.sm.toggleNodeSelection('n1');
+			libExpect(tmp.vs.SelectedNodeHashes).to.deep.equal(['n3']);
+			libExpect(tmp.vs.SelectedNodeHash).to.equal('n3');
+		});
+
+		test('toggling the last member empties the set and nulls the primary',
+		function ()
+		{
+			let tmp = makeManager(_Fable, _Nodes);
+			tmp.sm.toggleNodeSelection('n1');
+			tmp.sm.toggleNodeSelection('n1');
+			libExpect(tmp.vs.SelectedNodeHashes).to.deep.equal([]);
+			libExpect(tmp.vs.SelectedNodeHash).to.equal(null);
+		});
+	});
+
+	suite('selectNodes',
+	function ()
+	{
+		test('replaces the set and sets the primary to the last hash',
+		function ()
+		{
+			let tmp = makeManager(_Fable, _Nodes);
+			tmp.sm.selectNode('n1');
+			tmp.sm.selectNodes(['n2', 'n3']);
+			libExpect(tmp.vs.SelectedNodeHashes).to.deep.equal(['n2', 'n3']);
+			libExpect(tmp.vs.SelectedNodeHash).to.equal('n3');
+		});
+
+		test('an empty array clears the selection',
+		function ()
+		{
+			let tmp = makeManager(_Fable, _Nodes);
+			tmp.sm.selectNodes(['n1', 'n2']);
+			tmp.sm.selectNodes([]);
+			libExpect(tmp.vs.SelectedNodeHashes).to.deep.equal([]);
+			libExpect(tmp.vs.SelectedNodeHash).to.equal(null);
+		});
+
+		test('getSelectedNodeHashes returns a copy (mutating it does not change state)',
+		function ()
+		{
+			let tmp = makeManager(_Fable, _Nodes);
+			tmp.sm.selectNodes(['n1', 'n2']);
+			let tmpCopy = tmp.sm.getSelectedNodeHashes();
+			tmpCopy.push('n3');
+			libExpect(tmp.vs.SelectedNodeHashes).to.deep.equal(['n1', 'n2']);
+		});
+	});
+
+	suite('deleteSelected (multi)',
+	function ()
+	{
+		test('removes every node in the selection set',
+		function ()
+		{
+			let tmp = makeManager(_Fable, _Nodes);
+			tmp.sm.selectNodes(['n1', 'n3']);
+			let tmpResult = tmp.sm.deleteSelected();
+			libExpect(tmpResult).to.equal(true);
+			libExpect(tmp.fv._removed).to.deep.equal(['n1', 'n3']);
+			libExpect(tmp.vs.SelectedNodeHashes).to.deep.equal([]);
+			libExpect(tmp.vs.SelectedNodeHash).to.equal(null);
+		});
+
+		test('falls back to the single primary when the set is empty',
+		function ()
+		{
+			let tmp = makeManager(_Fable, _Nodes);
+			tmp.fv._FlowData.ViewState.SelectedNodeHash = 'n2';
+			tmp.fv._FlowData.ViewState.SelectedNodeHashes = [];
+			tmp.sm.deleteSelected();
+			libExpect(tmp.fv._removed).to.deep.equal(['n2']);
+		});
+
+		test('deletes the selected connection when no nodes are selected',
+		function ()
+		{
+			let tmp = makeManager(_Fable, _Nodes);
+			tmp.fv._FlowData.ViewState.SelectedConnectionHash = 'c1';
+			tmp.sm.deleteSelected();
+			libExpect(tmp.fv._removed).to.deep.equal(['conn:c1']);
+		});
+	});
+
+	suite('deselectAll',
+	function ()
+	{
+		test('clears the primary, the set, and the connection/tether selections',
+		function ()
+		{
+			let tmp = makeManager(_Fable, _Nodes);
+			tmp.sm.selectNodes(['n1', 'n2']);
+			tmp.fv._FlowData.ViewState.SelectedConnectionHash = 'c1';
+			tmp.sm.deselectAll();
+			libExpect(tmp.vs.SelectedNodeHash).to.equal(null);
+			libExpect(tmp.vs.SelectedNodeHashes).to.deep.equal([]);
+			libExpect(tmp.vs.SelectedConnectionHash).to.equal(null);
+		});
+	});
+});