pict-section-flow 0.0.17 → 0.0.19

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

@@ -0,0 +1,134 @@
+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

@@ -0,0 +1,209 @@
+const libCoerce = require('./Layout-Coerce.js');
+
+/**
+ * Layout-Layered
+ *
+ * Topological-sort (Kahn's algorithm) 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 : [];
+
+		// Build adjacency information
+		let tmpNodeMap = {};
+		let tmpInDegree = {};
+		let tmpOutEdges = {};
+
+		for (let i = 0; i < pNodes.length; i++)
+		{
+			let tmpNode = pNodes[i];
+			tmpNodeMap[tmpNode.Hash] = tmpNode;
+			tmpInDegree[tmpNode.Hash] = 0;
+			tmpOutEdges[tmpNode.Hash] = [];
+		}
+
+		for (let i = 0; i < tmpConnections.length; i++)
+		{
+			let tmpConn = tmpConnections[i];
+			if (tmpInDegree.hasOwnProperty(tmpConn.TargetNodeHash))
+			{
+				tmpInDegree[tmpConn.TargetNodeHash]++;
+			}
+			if (tmpOutEdges.hasOwnProperty(tmpConn.SourceNodeHash))
+			{
+				tmpOutEdges[tmpConn.SourceNodeHash].push(tmpConn.TargetNodeHash);
+			}
+		}
+
+		// Topological sort (Kahn's algorithm)
+		let tmpLayers = [];
+		let tmpQueue = [];
+		let tmpAssigned = {};
+
+		for (let tmpHash in tmpInDegree)
+		{
+			if (tmpInDegree[tmpHash] === 0)
+			{
+				tmpQueue.push(tmpHash);
+			}
+		}
+
+		while (tmpQueue.length > 0)
+		{
+			let tmpCurrentLayer = [];
+			let tmpNextQueue = [];
+
+			for (let i = 0; i < tmpQueue.length; i++)
+			{
+				let tmpNodeHash = tmpQueue[i];
+				if (tmpAssigned[tmpNodeHash]) continue;
+
+				tmpAssigned[tmpNodeHash] = true;
+				tmpCurrentLayer.push(tmpNodeHash);
+
+				let tmpEdges = tmpOutEdges[tmpNodeHash] || [];
+				for (let j = 0; j < tmpEdges.length; j++)
+				{
+					let tmpTargetHash = tmpEdges[j];
+					tmpInDegree[tmpTargetHash]--;
+					if (tmpInDegree[tmpTargetHash] <= 0 && !tmpAssigned[tmpTargetHash])
+					{
+						tmpNextQueue.push(tmpTargetHash);
+					}
+				}
+			}
+
+			if (tmpCurrentLayer.length > 0)
+			{
+				tmpLayers.push(tmpCurrentLayer);
+			}
+
+			tmpQueue = tmpNextQueue;
+		}
+
+		// Handle cycles or disconnected nodes
+		let tmpRemainingNodes = [];
+		for (let i = 0; i < pNodes.length; i++)
+		{
+			if (!tmpAssigned[pNodes[i].Hash])
+			{
+				tmpRemainingNodes.push(pNodes[i].Hash);
+			}
+		}
+		if (tmpRemainingNodes.length > 0)
+		{
+			tmpLayers.push(tmpRemainingNodes);
+		}
+
+		// Assign positions based on layers
+		let tmpCurrentX = tmpStartX;
+
+		for (let tmpLayerIndex = 0; tmpLayerIndex < tmpLayers.length; tmpLayerIndex++)
+		{
+			let tmpLayer = tmpLayers[tmpLayerIndex];
+			let tmpMaxWidth = 0;
+			let tmpCurrentY = tmpStartY;
+
+			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-Tabular.js

@@ -0,0 +1,94 @@
+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' }] }
+			}
+		}
+	}
+};