pict-section-flow 1.3.0 → 2.0.0

package/source/providers/layouts/Layout-Grid.js

@@ -1,134 +0,0 @@
-const libCoerce = require('./Layout-Coerce.js');
-
-/**
- * Layout-Grid
- *
- * Auto-arrange nodes in a roughly-square grid. Cell width and height
- * default to the largest node dimensions plus margins. Column count
- * defaults to ceil(sqrt(n)) when `Columns` is 'auto'.
- *
- * Continuous params (margins, cell sizes, origin) are typed
- * `PreciseNumber` so they survive solver chains; the integer column
- * count and the categorical OrderBy stay `Number` / enum.
- */
-module.exports =
-{
-	Name: 'Grid',
-	Label: 'Grid',
-	Description: 'Auto-arrange in a roughly-square grid.',
-	DefaultEdgeTheme: 'Orthogonal',
-
-	Apply: function (pNodes, pConnections, pParameters)
-	{
-		if (!pNodes || pNodes.length === 0) return;
-
-		let tmpParams = pParameters || {};
-		let tmpSpacing          = libCoerce.toFloat(tmpParams.Spacing, 1.0);
-		let tmpColumnsParam     = tmpParams.Columns;
-		let tmpCellWidthParam   = tmpParams.CellWidth;
-		let tmpCellHeightParam  = tmpParams.CellHeight;
-		let tmpHorizontalMargin = libCoerce.toFloat(tmpParams.HorizontalMargin, 40) * tmpSpacing;
-		let tmpVerticalMargin   = libCoerce.toFloat(tmpParams.VerticalMargin, 40) * tmpSpacing;
-		let tmpStartX           = libCoerce.toFloat(tmpParams.StartX, 100);
-		let tmpStartY           = libCoerce.toFloat(tmpParams.StartY, 100);
-		let tmpOrderBy          = tmpParams.OrderBy || 'index';
-
-		let tmpColumns;
-		if (tmpColumnsParam === 'auto' || tmpColumnsParam == null || tmpColumnsParam === '')
-		{
-			tmpColumns = Math.max(1, Math.ceil(Math.sqrt(pNodes.length)));
-		}
-		else
-		{
-			tmpColumns = Math.max(1, libCoerce.toInt(tmpColumnsParam, Math.max(1, Math.ceil(Math.sqrt(pNodes.length)))));
-		}
-
-		// Compute cell dimensions from largest node if not specified
-		let tmpMaxWidth = 0;
-		let tmpMaxHeight = 0;
-		for (let i = 0; i < pNodes.length; i++)
-		{
-			tmpMaxWidth = Math.max(tmpMaxWidth, pNodes[i].Width || 180);
-			tmpMaxHeight = Math.max(tmpMaxHeight, pNodes[i].Height || 80);
-		}
-
-		let tmpCellWidth  = (tmpCellWidthParam == null)  ? tmpMaxWidth + tmpHorizontalMargin  : libCoerce.toFloat(tmpCellWidthParam,  tmpMaxWidth + tmpHorizontalMargin);
-		let tmpCellHeight = (tmpCellHeightParam == null) ? tmpMaxHeight + tmpVerticalMargin : libCoerce.toFloat(tmpCellHeightParam, tmpMaxHeight + tmpVerticalMargin);
-
-		// Ordered iteration
-		let tmpOrdered = pNodes.slice();
-		if (tmpOrderBy === 'hash')
-		{
-			tmpOrdered.sort((pA, pB) => String(pA.Hash).localeCompare(String(pB.Hash)));
-		}
-		else if (tmpOrderBy === 'title')
-		{
-			tmpOrdered.sort((pA, pB) => String(pA.Title || pA.Hash).localeCompare(String(pB.Title || pB.Hash)));
-		}
-
-		for (let i = 0; i < tmpOrdered.length; i++)
-		{
-			let tmpRow = Math.floor(i / tmpColumns);
-			let tmpCol = i % tmpColumns;
-			tmpOrdered[i].X = tmpStartX + tmpCol * tmpCellWidth;
-			tmpOrdered[i].Y = tmpStartY + tmpRow * tmpCellHeight;
-		}
-	},
-
-	DefaultParameters:
-	{
-		Spacing: 1.0,
-		Columns: 'auto',
-		HorizontalMargin: 40,
-		VerticalMargin: 40,
-		StartX: 100,
-		StartY: 100,
-		OrderBy: 'index'
-	},
-
-	ParameterSchema:
-	{
-		Spacing:          { Type: 'PreciseNumber', Label: 'Spacing (multiplier)', Default: 1.0, Min: 0.1, Max: 5 },
-		Columns:          { Type: 'string',        Label: 'Columns',          Default: 'auto', Description: '"auto" or an integer' },
-		CellWidth:        { Type: 'PreciseNumber', Label: 'Cell width',       Description: 'Defaults to largest node width + horizontal margin', Min: 1, Max: 5000 },
-		CellHeight:       { Type: 'PreciseNumber', Label: 'Cell height',      Description: 'Defaults to largest node height + vertical margin', Min: 1, Max: 5000 },
-		HorizontalMargin: { Type: 'PreciseNumber', Label: 'Horizontal margin', Default: 40, Min: 0, Max: 1000 },
-		VerticalMargin:   { Type: 'PreciseNumber', Label: 'Vertical margin',   Default: 40, Min: 0, Max: 1000 },
-		StartX:           { Type: 'PreciseNumber', Label: 'Start X',          Default: 100, Min: -10000, Max: 10000 },
-		StartY:           { Type: 'PreciseNumber', Label: 'Start Y',          Default: 100, Min: -10000, Max: 10000 },
-		OrderBy:          { Type: 'enum',          Label: 'Order by',         Default: 'index', Options: ['index', 'hash', 'title'] }
-	},
-
-	ParameterManifest:
-	{
-		Scope: 'PictFlowLayout-Grid',
-		Sections:
-		[
-			{ Name: 'Grid Parameters', Hash: 'PFLGridSection', Groups: [{ Name: 'Defaults', Hash: 'PFLGridGroup' }] }
-		],
-		Descriptors:
-		{
-			'PictFlowLayoutEditor.Parameters.Spacing':
-			{ Name: 'Spacing (multiplier)', Hash: 'Spacing', DataType: 'PreciseNumber', Default: 1.0, PictForm: { Section: 'PFLGridSection', Group: 'PFLGridGroup', Row: 0, Width: 12, Min: 0.1, Max: 5 } },
-			'PictFlowLayoutEditor.Parameters.Columns':
-			{ Name: 'Columns ("auto" or integer)', Hash: 'Columns', DataType: 'String', Default: 'auto', PictForm: { Section: 'PFLGridSection', Group: 'PFLGridGroup', Row: 1, Width: 6 } },
-			'PictFlowLayoutEditor.Parameters.OrderBy':
-			{
-				Name: 'Order by', Hash: 'OrderBy', DataType: 'String', Default: 'index',
-				PictForm: { Section: 'PFLGridSection', Group: 'PFLGridGroup', Row: 1, Width: 6, InputType: 'Option', SelectOptions: [{ Value: 'index', Name: 'Index' }, { Value: 'hash', Name: 'Hash' }, { Value: 'title', Name: 'Title' }] }
-			},
-			'PictFlowLayoutEditor.Parameters.CellWidth':
-			{ Name: 'Cell width (auto = blank)', Hash: 'CellWidth', DataType: 'PreciseNumber', PictForm: { Section: 'PFLGridSection', Group: 'PFLGridGroup', Row: 2, Width: 6, Min: 1, Max: 5000 } },
-			'PictFlowLayoutEditor.Parameters.CellHeight':
-			{ Name: 'Cell height (auto = blank)', Hash: 'CellHeight', DataType: 'PreciseNumber', PictForm: { Section: 'PFLGridSection', Group: 'PFLGridGroup', Row: 2, Width: 6, Min: 1, Max: 5000 } },
-			'PictFlowLayoutEditor.Parameters.HorizontalMargin':
-			{ Name: 'Horizontal margin', Hash: 'HorizontalMargin', DataType: 'PreciseNumber', Default: 40, PictForm: { Section: 'PFLGridSection', Group: 'PFLGridGroup', Row: 3, Width: 6, Min: 0, Max: 1000 } },
-			'PictFlowLayoutEditor.Parameters.VerticalMargin':
-			{ Name: 'Vertical margin', Hash: 'VerticalMargin', DataType: 'PreciseNumber', Default: 40, PictForm: { Section: 'PFLGridSection', Group: 'PFLGridGroup', Row: 3, Width: 6, Min: 0, Max: 1000 } },
-			'PictFlowLayoutEditor.Parameters.StartX':
-			{ Name: 'Start X', Hash: 'StartX', DataType: 'PreciseNumber', Default: 100, PictForm: { Section: 'PFLGridSection', Group: 'PFLGridGroup', Row: 4, Width: 6, Min: -10000, Max: 10000 } },
-			'PictFlowLayoutEditor.Parameters.StartY':
-			{ Name: 'Start Y', Hash: 'StartY', DataType: 'PreciseNumber', Default: 100, PictForm: { Section: 'PFLGridSection', Group: 'PFLGridGroup', Row: 4, Width: 6, Min: -10000, Max: 10000 } }
-		}
-	}
-};

package/source/providers/layouts/Layout-Layered.js

@@ -1,155 +0,0 @@
-const libCoerce = require('./Layout-Coerce.js');
-const libRank = require('./Layout-Rank.js');
-
-/**
- * Layout-Layered
- *
- * Cycle-tolerant left-to-right layered layout.
- *
- * This is the original `autoLayout` behavior of pict-section-flow,
- * extracted into a layout-algorithm descriptor. Calling
- * `_LayoutService.autoLayout(nodes, connections)` with no algorithm
- * argument dispatches here, preserving backwards compatibility.
- *
- * Numeric parameters are typed `PreciseNumber` (big.js-backed strings)
- * so they survive ExpressionParser solver chains without float drift;
- * the simulation coerces back to JS floats at entry via Layout-Coerce.
- */
-module.exports =
-{
-	Name: 'Layered',
-	Label: 'Layered (Topological)',
-	Description: 'Left-to-right layers based on connection topology.',
-	DefaultEdgeTheme: 'Orthogonal',
-
-	Apply: function (pNodes, pConnections, pParameters)
-	{
-		if (!pNodes || pNodes.length === 0) return;
-
-		let tmpParams = pParameters || {};
-		let tmpSpacing           = libCoerce.toFloat(tmpParams.Spacing, 1.0);
-		let tmpHorizontalSpacing = libCoerce.toFloat(tmpParams.HorizontalSpacing, 250) * tmpSpacing;
-		let tmpVerticalSpacing   = libCoerce.toFloat(tmpParams.VerticalSpacing, 120) * tmpSpacing;
-		let tmpStartX            = libCoerce.toFloat(tmpParams.StartX, 100);
-		let tmpStartY            = libCoerce.toFloat(tmpParams.StartY, 100);
-
-		let tmpConnections = Array.isArray(pConnections) ? pConnections : [];
-
-		let tmpNodeMap = {};
-		for (let i = 0; i < pNodes.length; i++)
-		{
-			tmpNodeMap[pNodes[i].Hash] = pNodes[i];
-		}
-
-		// Rank the nodes into layers, left to right, with cycle breaking. The
-		// shared ranker keeps back-edged graphs (workflows, state machines) from
-		// collapsing into one tall column the way plain Kahn's topological sort
-		// would. See Layout-Rank.js.
-		let tmpLayers = libRank.toRanks(pNodes, tmpConnections);
-
-		// Measure each layer's stacked height so layers can be centered on one
-		// shared horizontal axis. Without centering every layer top-aligns at
-		// StartY, so a one-node layer beside a five-node layer reads as a
-		// diagonal drift down the page instead of a balanced band.
-		let tmpLayerHeights = [];
-		let tmpMaxLayerHeight = 0;
-		for (let l = 0; l < tmpLayers.length; l++)
-		{
-			let tmpHeight = 0;
-			for (let i = 0; i < tmpLayers[l].length; i++)
-			{
-				let tmpNode = tmpNodeMap[tmpLayers[l][i]];
-				tmpHeight += (tmpNode && tmpNode.Height) ? tmpNode.Height : 80;
-				if (i > 0) tmpHeight += tmpVerticalSpacing;
-			}
-			tmpLayerHeights.push(tmpHeight);
-			if (tmpHeight > tmpMaxLayerHeight) tmpMaxLayerHeight = tmpHeight;
-		}
-
-		// Assign positions: one column per layer, each layer vertically centered.
-		let tmpCurrentX = tmpStartX;
-
-		for (let tmpLayerIndex = 0; tmpLayerIndex < tmpLayers.length; tmpLayerIndex++)
-		{
-			let tmpLayer = tmpLayers[tmpLayerIndex];
-			let tmpMaxWidth = 0;
-			let tmpCurrentY = tmpStartY + ((tmpMaxLayerHeight - tmpLayerHeights[tmpLayerIndex]) / 2);
-
-			for (let i = 0; i < tmpLayer.length; i++)
-			{
-				let tmpNode = tmpNodeMap[tmpLayer[i]];
-				if (!tmpNode) continue;
-
-				tmpNode.X = tmpCurrentX;
-				tmpNode.Y = tmpCurrentY;
-
-				let tmpWidth = tmpNode.Width || 180;
-				let tmpHeight = tmpNode.Height || 80;
-
-				tmpMaxWidth = Math.max(tmpMaxWidth, tmpWidth);
-				tmpCurrentY += tmpHeight + tmpVerticalSpacing;
-			}
-
-			tmpCurrentX += tmpMaxWidth + tmpHorizontalSpacing;
-		}
-	},
-
-	DefaultParameters:
-	{
-		Spacing: 1.0,
-		HorizontalSpacing: 250,
-		VerticalSpacing: 120,
-		StartX: 100,
-		StartY: 100
-	},
-
-	ParameterSchema:
-	{
-		Spacing:           { Type: 'PreciseNumber', Label: 'Spacing (multiplier)', Default: 1.0, Min: 0.1, Max: 5 },
-		HorizontalSpacing: { Type: 'PreciseNumber', Label: 'Horizontal spacing', Default: 250, Min: 0, Max: 1000 },
-		VerticalSpacing:   { Type: 'PreciseNumber', Label: 'Vertical spacing',   Default: 120, Min: 0, Max: 1000 },
-		StartX:            { Type: 'PreciseNumber', Label: 'Start X',            Default: 100, Min: -10000, Max: 10000 },
-		StartY:            { Type: 'PreciseNumber', Label: 'Start Y',            Default: 100, Min: -10000, Max: 10000 }
-	},
-
-	// Manyfest descriptor catalog consumed by pict-section-form's metacontroller.
-	// Descriptor keys are full data paths relative to the marshal destination
-	// (default `AppData`); the toolbar binds `AppData.PictFlowLayoutEditor.Parameters`
-	// to the active flow's `_FlowData.LayoutParameters` before injecting.
-	ParameterManifest:
-	{
-		Scope: 'PictFlowLayout-Layered',
-		Sections:
-		[
-			{ Name: 'Layered Parameters', Hash: 'PictFlowLayoutSection', Groups: [{ Name: 'Defaults', Hash: 'PictFlowLayoutGroup' }] }
-		],
-		Descriptors:
-		{
-			'PictFlowLayoutEditor.Parameters.Spacing':
-			{
-				Name: 'Spacing (multiplier)', Hash: 'Spacing', DataType: 'PreciseNumber', Default: 1.0,
-				PictForm: { Section: 'PictFlowLayoutSection', Group: 'PictFlowLayoutGroup', Row: 0, Width: 12, Min: 0.1, Max: 5 }
-			},
-			'PictFlowLayoutEditor.Parameters.HorizontalSpacing':
-			{
-				Name: 'Horizontal spacing', Hash: 'HorizontalSpacing', DataType: 'PreciseNumber', Default: 250,
-				PictForm: { Section: 'PictFlowLayoutSection', Group: 'PictFlowLayoutGroup', Row: 1, Width: 6, Min: 0, Max: 1000 }
-			},
-			'PictFlowLayoutEditor.Parameters.VerticalSpacing':
-			{
-				Name: 'Vertical spacing', Hash: 'VerticalSpacing', DataType: 'PreciseNumber', Default: 120,
-				PictForm: { Section: 'PictFlowLayoutSection', Group: 'PictFlowLayoutGroup', Row: 1, Width: 6, Min: 0, Max: 1000 }
-			},
-			'PictFlowLayoutEditor.Parameters.StartX':
-			{
-				Name: 'Start X', Hash: 'StartX', DataType: 'PreciseNumber', Default: 100,
-				PictForm: { Section: 'PictFlowLayoutSection', Group: 'PictFlowLayoutGroup', Row: 2, Width: 6, Min: -10000, Max: 10000 }
-			},
-			'PictFlowLayoutEditor.Parameters.StartY':
-			{
-				Name: 'Start Y', Hash: 'StartY', DataType: 'PreciseNumber', Default: 100,
-				PictForm: { Section: 'PictFlowLayoutSection', Group: 'PictFlowLayoutGroup', Row: 2, Width: 6, Min: -10000, Max: 10000 }
-			}
-		}
-	}
-};

package/source/providers/layouts/Layout-Rank.js

@@ -1,141 +0,0 @@
-/**
- * Layout-Rank
- *
- * Shared cycle-tolerant topological ranking for the directed layouts
- * (Layered, Staggered).
- *
- * Plain Kahn's topological sort drops every node that participates in a cycle
- * into a single trailing rank. Any graph with back-edges (workflows, state
- * machines: rejections, retries, "send back") therefore collapses into one
- * tall stripe of unranked nodes, which is the historical "auto-layout bunches
- * everything together and is useless" behavior.
- *
- * `toRanks` instead breaks each cycle at its most-resolved node: when a round
- * finds nothing dependency-free but nodes remain, it forces the unassigned
- * node with the fewest unmet predecessors into the next rank and continues.
- * Cyclic graphs then rank left to right the same way a DAG does.
- *
- * Returns an array of ranks; each rank is an array of node Hashes in stable
- * source order. Self-loops are ignored for ranking (they cannot define an
- * order). Callers map Hashes back to node objects themselves.
- */
-function toRanks(pNodes, pConnections)
-{
-	let tmpRanks = [];
-	if (!pNodes || pNodes.length === 0)
-	{
-		return tmpRanks;
-	}
-
-	let tmpConnections = Array.isArray(pConnections) ? pConnections : [];
-
-	let tmpInDegree = {};
-	let tmpOutEdges = {};
-	for (let i = 0; i < pNodes.length; i++)
-	{
-		tmpInDegree[pNodes[i].Hash] = 0;
-		tmpOutEdges[pNodes[i].Hash] = [];
-	}
-
-	for (let i = 0; i < tmpConnections.length; i++)
-	{
-		let tmpConn = tmpConnections[i];
-		// A self-loop cannot define a rank order; skip it.
-		if (tmpConn.SourceNodeHash === tmpConn.TargetNodeHash)
-		{
-			continue;
-		}
-		if (tmpInDegree.hasOwnProperty(tmpConn.TargetNodeHash))
-		{
-			tmpInDegree[tmpConn.TargetNodeHash]++;
-		}
-		if (tmpOutEdges.hasOwnProperty(tmpConn.SourceNodeHash))
-		{
-			tmpOutEdges[tmpConn.SourceNodeHash].push(tmpConn.TargetNodeHash);
-		}
-	}
-
-	let tmpAssigned = {};
-	let tmpAssignedCount = 0;
-
-	while (tmpAssignedCount < pNodes.length)
-	{
-		let tmpRank = [];
-
-		for (let i = 0; i < pNodes.length; i++)
-		{
-			let tmpHash = pNodes[i].Hash;
-			if (!tmpAssigned[tmpHash] && tmpInDegree[tmpHash] <= 0)
-			{
-				tmpRank.push(tmpHash);
-			}
-		}
-
-		if (tmpRank.length === 0)
-		{
-			// Cycle break: nothing is dependency-free, so force the unassigned
-			// node with the fewest remaining predecessors (ties keep source
-			// order, which keeps the result stable across runs).
-			let tmpMinDegree = Infinity;
-			let tmpPick = null;
-			for (let i = 0; i < pNodes.length; i++)
-			{
-				let tmpHash = pNodes[i].Hash;
-				if (!tmpAssigned[tmpHash] && tmpInDegree[tmpHash] < tmpMinDegree)
-				{
-					tmpMinDegree = tmpInDegree[tmpHash];
-					tmpPick = tmpHash;
-				}
-			}
-			if (tmpPick === null)
-			{
-				break; // safety; every node is already assigned
-			}
-			tmpRank.push(tmpPick);
-		}
-
-		// Commit the whole rank, then relax its out-edges so the next round
-		// sees the successors it just freed.
-		for (let i = 0; i < tmpRank.length; i++)
-		{
-			tmpAssigned[tmpRank[i]] = true;
-			tmpAssignedCount++;
-		}
-		for (let i = 0; i < tmpRank.length; i++)
-		{
-			let tmpEdges = tmpOutEdges[tmpRank[i]] || [];
-			for (let j = 0; j < tmpEdges.length; j++)
-			{
-				tmpInDegree[tmpEdges[j]]--;
-			}
-		}
-
-		tmpRanks.push(tmpRank);
-	}
-
-	return tmpRanks;
-}
-
-/**
- * Flatten ranks to a single ordered list of node Hashes (rank by rank, source
- * order within a rank). Convenience for layouts that walk one sequence.
- */
-function toOrder(pNodes, pConnections)
-{
-	let tmpRanks = toRanks(pNodes, pConnections);
-	let tmpOrder = [];
-	for (let i = 0; i < tmpRanks.length; i++)
-	{
-		for (let j = 0; j < tmpRanks[i].length; j++)
-		{
-			tmpOrder.push(tmpRanks[i][j]);
-		}
-	}
-	return tmpOrder;
-}
-
-module.exports =
-{
-	toRanks: toRanks,
-	toOrder: toOrder
-};

package/source/providers/layouts/Layout-Staggered.js

@@ -1,131 +0,0 @@
-const libCoerce = require('./Layout-Coerce.js');
-const libRank = require('./Layout-Rank.js');
-
-/**
- * Layout-Staggered
- *
- * Serpentine "stairstep" layout for directed graphs. It ranks the nodes left
- * to right by connection topology (the same cycle-tolerant ranking the Layered
- * layout uses), then walks that ordered sequence along a band that steps down a
- * few rows and back up, advancing horizontally at every node.
- *
- * The point is vertical-space efficiency: a long directed chain (a workflow, a
- * delivery pipeline, a state machine) laid out purely left to right runs off
- * the right edge of the canvas. Folding it into a stairstep band keeps the
- * left-to-right reading order while using the height of the viewport, so the
- * whole graph frames at a usable zoom.
- *
- * `Rows` sets how deep the band steps before folding back: 2 is a simple
- * zigzag (odd nodes high, even nodes low); 3+ is a deeper stairstep. The row
- * index follows a triangle wave so the band descends and then climbs rather
- * than snapping back to the top between runs.
- *
- * Numeric parameters are typed `PreciseNumber` so they survive ExpressionParser
- * solver chains; Layout-Coerce converts them back to JS floats at entry.
- */
-module.exports =
-{
-	Name: 'Staggered',
-	Label: 'Staggered (Stairstep)',
-	Description: 'Topological order folded along a serpentine stairstep band.',
-	DefaultEdgeTheme: 'Perimeter',
-
-	Apply: function (pNodes, pConnections, pParameters)
-	{
-		if (!pNodes || pNodes.length === 0) return;
-
-		let tmpParams = pParameters || {};
-		let tmpSpacing       = libCoerce.toFloat(tmpParams.Spacing, 1.0);
-		let tmpRows          = Math.max(1, libCoerce.toInt(tmpParams.Rows, 2));
-		let tmpColumnSpacing = libCoerce.toFloat(tmpParams.ColumnSpacing, 80) * tmpSpacing;
-		let tmpRowOffset     = libCoerce.toFloat(tmpParams.RowOffset, 150) * tmpSpacing;
-		let tmpStartX        = libCoerce.toFloat(tmpParams.StartX, 80);
-		let tmpStartY        = libCoerce.toFloat(tmpParams.StartY, 80);
-
-		let tmpConnections = Array.isArray(pConnections) ? pConnections : [];
-
-		let tmpNodeMap = {};
-		for (let i = 0; i < pNodes.length; i++)
-		{
-			tmpNodeMap[pNodes[i].Hash] = pNodes[i];
-		}
-
-		let tmpOrder = libRank.toOrder(pNodes, tmpConnections);
-
-		// A uniform column pitch (the widest node plus the spacing) keeps the
-		// stairstep diagonal even regardless of individual node widths.
-		let tmpMaxWidth = 0;
-		for (let i = 0; i < pNodes.length; i++)
-		{
-			tmpMaxWidth = Math.max(tmpMaxWidth, pNodes[i].Width || 180);
-		}
-		let tmpColumnPitch = tmpMaxWidth + tmpColumnSpacing;
-
-		// Triangle wave: descend (Rows - 1) steps, then climb (Rows - 1) steps.
-		let tmpPeriod = (tmpRows > 1) ? (2 * (tmpRows - 1)) : 1;
-
-		for (let i = 0; i < tmpOrder.length; i++)
-		{
-			let tmpNode = tmpNodeMap[tmpOrder[i]];
-			if (!tmpNode) continue;
-
-			let tmpRow;
-			if (tmpRows <= 1)
-			{
-				tmpRow = 0;
-			}
-			else
-			{
-				let tmpPhase = i % tmpPeriod;
-				tmpRow = (tmpPhase < tmpRows) ? tmpPhase : (tmpPeriod - tmpPhase);
-			}
-
-			tmpNode.X = tmpStartX + (i * tmpColumnPitch);
-			tmpNode.Y = tmpStartY + (tmpRow * tmpRowOffset);
-		}
-	},
-
-	DefaultParameters:
-	{
-		Spacing: 1.0,
-		Rows: 2,
-		ColumnSpacing: 80,
-		RowOffset: 150,
-		StartX: 80,
-		StartY: 80
-	},
-
-	ParameterSchema:
-	{
-		Spacing:       { Type: 'PreciseNumber', Label: 'Spacing (multiplier)', Default: 1.0, Min: 0.1, Max: 5 },
-		Rows:          { Type: 'Number',        Label: 'Rows',          Default: 2,   Min: 1, Max: 12 },
-		ColumnSpacing: { Type: 'PreciseNumber', Label: 'Column spacing', Default: 80,  Min: 0, Max: 1000 },
-		RowOffset:     { Type: 'PreciseNumber', Label: 'Row offset',    Default: 150, Min: 0, Max: 1000 },
-		StartX:        { Type: 'PreciseNumber', Label: 'Start X',       Default: 80,  Min: -10000, Max: 10000 },
-		StartY:        { Type: 'PreciseNumber', Label: 'Start Y',       Default: 80,  Min: -10000, Max: 10000 }
-	},
-
-	ParameterManifest:
-	{
-		Scope: 'PictFlowLayout-Staggered',
-		Sections:
-		[
-			{ Name: 'Staggered Parameters', Hash: 'PFLStaggeredSection', Groups: [{ Name: 'Defaults', Hash: 'PFLStaggeredGroup' }] }
-		],
-		Descriptors:
-		{
-			'PictFlowLayoutEditor.Parameters.Spacing':
-			{ Name: 'Spacing (multiplier)', Hash: 'Spacing', DataType: 'PreciseNumber', Default: 1.0, PictForm: { Section: 'PFLStaggeredSection', Group: 'PFLStaggeredGroup', Row: 0, Width: 6, Min: 0.1, Max: 5 } },
-			'PictFlowLayoutEditor.Parameters.Rows':
-			{ Name: 'Rows', Hash: 'Rows', DataType: 'Number', Default: 2, PictForm: { Section: 'PFLStaggeredSection', Group: 'PFLStaggeredGroup', Row: 0, Width: 6, Min: 1, Max: 12 } },
-			'PictFlowLayoutEditor.Parameters.ColumnSpacing':
-			{ Name: 'Column spacing', Hash: 'ColumnSpacing', DataType: 'PreciseNumber', Default: 80, PictForm: { Section: 'PFLStaggeredSection', Group: 'PFLStaggeredGroup', Row: 1, Width: 6, Min: 0, Max: 1000 } },
-			'PictFlowLayoutEditor.Parameters.RowOffset':
-			{ Name: 'Row offset', Hash: 'RowOffset', DataType: 'PreciseNumber', Default: 150, PictForm: { Section: 'PFLStaggeredSection', Group: 'PFLStaggeredGroup', Row: 1, Width: 6, Min: 0, Max: 1000 } },
-			'PictFlowLayoutEditor.Parameters.StartX':
-			{ Name: 'Start X', Hash: 'StartX', DataType: 'PreciseNumber', Default: 80, PictForm: { Section: 'PFLStaggeredSection', Group: 'PFLStaggeredGroup', Row: 2, Width: 6, Min: -10000, Max: 10000 } },
-			'PictFlowLayoutEditor.Parameters.StartY':
-			{ Name: 'Start Y', Hash: 'StartY', DataType: 'PreciseNumber', Default: 80, PictForm: { Section: 'PFLStaggeredSection', Group: 'PFLStaggeredGroup', Row: 2, Width: 6, Min: -10000, Max: 10000 } }
-		}
-	}
-};

package/source/providers/layouts/Layout-Tabular.js

@@ -1,94 +0,0 @@
-const libCoerce = require('./Layout-Coerce.js');
-
-/**
- * Layout-Tabular
- *
- * Vertical single-column flow. Nodes are stacked top-to-bottom with
- * VerticalSpacing between successive rows.
- */
-module.exports =
-{
-	Name: 'Tabular',
-	Label: 'Tabular (Top-to-Bottom)',
-	Description: 'Single column, top-to-bottom.',
-	DefaultEdgeTheme: 'Orthogonal',
-
-	Apply: function (pNodes, pConnections, pParameters)
-	{
-		if (!pNodes || pNodes.length === 0) return;
-
-		let tmpParams = pParameters || {};
-		let tmpSpacing         = libCoerce.toFloat(tmpParams.Spacing, 1.0);
-		let tmpStartX          = libCoerce.toFloat(tmpParams.StartX, 100);
-		let tmpStartY          = libCoerce.toFloat(tmpParams.StartY, 100);
-		let tmpVerticalSpacing = libCoerce.toFloat(tmpParams.VerticalSpacing, 40) * tmpSpacing;
-		let tmpRowHeightParam  = tmpParams.RowHeight;
-		let tmpOrderBy         = tmpParams.OrderBy || 'index';
-
-		let tmpOrdered = pNodes.slice();
-		if (tmpOrderBy === 'hash')
-		{
-			tmpOrdered.sort((pA, pB) => String(pA.Hash).localeCompare(String(pB.Hash)));
-		}
-		else if (tmpOrderBy === 'title')
-		{
-			tmpOrdered.sort((pA, pB) => String(pA.Title || pA.Hash).localeCompare(String(pB.Title || pB.Hash)));
-		}
-
-		let tmpY = tmpStartY;
-		for (let i = 0; i < tmpOrdered.length; i++)
-		{
-			let tmpNode = tmpOrdered[i];
-			tmpNode.X = tmpStartX;
-			tmpNode.Y = tmpY;
-			let tmpRowHeight = (tmpRowHeightParam == null) ? (tmpNode.Height || 80) : libCoerce.toFloat(tmpRowHeightParam, tmpNode.Height || 80);
-			tmpY += tmpRowHeight + tmpVerticalSpacing;
-		}
-	},
-
-	DefaultParameters:
-	{
-		Spacing: 1.0,
-		StartX: 100,
-		StartY: 100,
-		VerticalSpacing: 40,
-		OrderBy: 'index'
-	},
-
-	ParameterSchema:
-	{
-		Spacing:         { Type: 'PreciseNumber', Label: 'Spacing (multiplier)', Default: 1.0, Min: 0.1, Max: 5 },
-		StartX:          { Type: 'PreciseNumber', Label: 'Start X',          Default: 100, Min: -10000, Max: 10000 },
-		StartY:          { Type: 'PreciseNumber', Label: 'Start Y',          Default: 100, Min: -10000, Max: 10000 },
-		VerticalSpacing: { Type: 'PreciseNumber', Label: 'Vertical spacing', Default: 40,  Min: 0, Max: 1000 },
-		RowHeight:       { Type: 'PreciseNumber', Label: 'Row height',       Description: 'Defaults to each node\'s own height', Min: 1, Max: 5000 },
-		OrderBy:         { Type: 'enum',          Label: 'Order by',         Default: 'index', Options: ['index', 'hash', 'title'] }
-	},
-
-	ParameterManifest:
-	{
-		Scope: 'PictFlowLayout-Tabular',
-		Sections:
-		[
-			{ Name: 'Tabular Parameters', Hash: 'PFLTabularSection', Groups: [{ Name: 'Defaults', Hash: 'PFLTabularGroup' }] }
-		],
-		Descriptors:
-		{
-			'PictFlowLayoutEditor.Parameters.Spacing':
-			{ Name: 'Spacing (multiplier)', Hash: 'Spacing', DataType: 'PreciseNumber', Default: 1.0, PictForm: { Section: 'PFLTabularSection', Group: 'PFLTabularGroup', Row: 0, Width: 12, Min: 0.1, Max: 5 } },
-			'PictFlowLayoutEditor.Parameters.StartX':
-			{ Name: 'Start X', Hash: 'StartX', DataType: 'PreciseNumber', Default: 100, PictForm: { Section: 'PFLTabularSection', Group: 'PFLTabularGroup', Row: 1, Width: 6, Min: -10000, Max: 10000 } },
-			'PictFlowLayoutEditor.Parameters.StartY':
-			{ Name: 'Start Y', Hash: 'StartY', DataType: 'PreciseNumber', Default: 100, PictForm: { Section: 'PFLTabularSection', Group: 'PFLTabularGroup', Row: 1, Width: 6, Min: -10000, Max: 10000 } },
-			'PictFlowLayoutEditor.Parameters.VerticalSpacing':
-			{ Name: 'Vertical spacing', Hash: 'VerticalSpacing', DataType: 'PreciseNumber', Default: 40, PictForm: { Section: 'PFLTabularSection', Group: 'PFLTabularGroup', Row: 2, Width: 6, Min: 0, Max: 1000 } },
-			'PictFlowLayoutEditor.Parameters.RowHeight':
-			{ Name: 'Row height (auto = blank)', Hash: 'RowHeight', DataType: 'PreciseNumber', PictForm: { Section: 'PFLTabularSection', Group: 'PFLTabularGroup', Row: 2, Width: 6, Min: 1, Max: 5000 } },
-			'PictFlowLayoutEditor.Parameters.OrderBy':
-			{
-				Name: 'Order by', Hash: 'OrderBy', DataType: 'String', Default: 'index',
-				PictForm: { Section: 'PFLTabularSection', Group: 'PFLTabularGroup', Row: 3, Width: 12, InputType: 'Option', SelectOptions: [{ Value: 'index', Name: 'Index' }, { Value: 'hash', Name: 'Hash' }, { Value: 'title', Name: 'Title' }] }
-			}
-		}
-	}
-};