pict-section-flow 0.0.16 → 0.0.18

package/source/providers/edges/Edge-Bezier.js

@@ -0,0 +1,41 @@
+/**
+ * Edge-Bezier
+ *
+ * Default edge theme: smooth cubic bezier between source and target ports,
+ * with departure/approach geometry derived from each port's `Side`. This
+ * is a thin wrapper around the renderer's pre-existing bezier path
+ * generator — selecting it is equivalent to the historical default.
+ *
+ * Honors per-connection multi-handle waypoints (BezierHandles) when
+ * present so user-edited curves still survive.
+ */
+module.exports =
+{
+	Name: 'Bezier',
+	Label: 'Bezier (smooth)',
+	Description: 'Smooth cubic curves with side-aware departures.',
+
+	GeneratePath: function (pContext)
+	{
+		let tmpHelpers = pContext.Helpers;
+		let tmpSrc = pContext.Source;
+		let tmpTgt = pContext.Target;
+		let tmpData = (pContext.Connection && pContext.Connection.Data) || {};
+
+		// Preserve user-customized multi-handle bezier waypoints.
+		if (tmpData.HandleCustomized)
+		{
+			let tmpHandles = tmpHelpers.getBezierHandles(tmpData);
+			if (tmpHandles.length > 0)
+			{
+				return tmpHelpers.generateMultiBezier(tmpSrc, tmpTgt, tmpHandles);
+			}
+		}
+
+		return tmpHelpers.generateBezier(tmpSrc, tmpTgt);
+	},
+
+	DefaultParameters: {},
+
+	ParameterSchema: {}
+};

package/source/providers/edges/Edge-Orthogonal.js

@@ -0,0 +1,37 @@
+/**
+ * Edge-Orthogonal
+ *
+ * Right-angle (Manhattan) routing between source and target. Reads
+ * cleanly for layered DAGs and grid-shaped layouts. Per-connection
+ * `OrthoMidOffset` and customized corner overrides are preserved.
+ */
+module.exports =
+{
+	Name: 'Orthogonal',
+	Label: 'Orthogonal (right-angle)',
+	Description: 'Right-angle routing — reads well for DAGs and grids.',
+
+	GeneratePath: function (pContext)
+	{
+		let tmpHelpers = pContext.Helpers;
+		let tmpSrc = pContext.Source;
+		let tmpTgt = pContext.Target;
+		let tmpData = (pContext.Connection && pContext.Connection.Data) || {};
+
+		let tmpCorners = null;
+		if (tmpData.HandleCustomized && tmpData.OrthoCorner1X != null)
+		{
+			tmpCorners =
+			{
+				corner1: { x: tmpData.OrthoCorner1X, y: tmpData.OrthoCorner1Y },
+				corner2: { x: tmpData.OrthoCorner2X, y: tmpData.OrthoCorner2Y }
+			};
+		}
+
+		return tmpHelpers.generateOrthogonal(tmpSrc, tmpTgt, tmpCorners, tmpData.OrthoMidOffset || 0);
+	},
+
+	DefaultParameters: {},
+
+	ParameterSchema: {}
+};

package/source/providers/edges/Edge-OrthogonalSnap.js

@@ -0,0 +1,72 @@
+const libCoerce = require('../layouts/Layout-Coerce.js');
+
+/**
+ * Edge-OrthogonalSnap
+ *
+ * Demonstrates the "edge theme can affect node placement" axis. Same
+ * right-angle routing as Edge-Orthogonal, but with an `AdjustLayout`
+ * pass that snaps every node's X/Y to a grid so corner segments line
+ * up cleanly across the diagram.
+ *
+ * Trade-off: nodes shift slightly from the layout's natural positions
+ * to gain visual alignment. The user opts into this by picking the
+ * theme — the layout algorithm itself is unaware.
+ */
+module.exports =
+{
+	Name: 'OrthogonalSnap',
+	Label: 'Orthogonal (snap to grid)',
+	Description: 'Right-angle routing; snaps node positions to a grid for cleaner corner alignment. Demonstrates an edge theme that adjusts node placement.',
+
+	GeneratePath: function (pContext)
+	{
+		let tmpHelpers = pContext.Helpers;
+		let tmpSrc = pContext.Source;
+		let tmpTgt = pContext.Target;
+		let tmpData = (pContext.Connection && pContext.Connection.Data) || {};
+
+		let tmpCorners = null;
+		if (tmpData.HandleCustomized && tmpData.OrthoCorner1X != null)
+		{
+			tmpCorners =
+			{
+				corner1: { x: tmpData.OrthoCorner1X, y: tmpData.OrthoCorner1Y },
+				corner2: { x: tmpData.OrthoCorner2X, y: tmpData.OrthoCorner2Y }
+			};
+		}
+
+		return tmpHelpers.generateOrthogonal(tmpSrc, tmpTgt, tmpCorners, tmpData.OrthoMidOffset || 0);
+	},
+
+	/**
+	 * Snap each node's (X, Y) to the configured grid after the layout
+	 * has run. Mutates pNodes in place.
+	 *
+	 * @param {Array} pNodes
+	 * @param {Array} pConnections
+	 * @param {Object} pParameters
+	 */
+	AdjustLayout: function (pNodes, pConnections, pParameters)
+	{
+		let tmpGridSize = libCoerce.toFloat((pParameters || {}).GridSize, 20);
+		if (tmpGridSize <= 0) return;
+
+		for (let i = 0; i < pNodes.length; i++)
+		{
+			let tmpNode = pNodes[i];
+			if (typeof tmpNode.X !== 'number' || typeof tmpNode.Y !== 'number') continue;
+			tmpNode.X = Math.round(tmpNode.X / tmpGridSize) * tmpGridSize;
+			tmpNode.Y = Math.round(tmpNode.Y / tmpGridSize) * tmpGridSize;
+		}
+	},
+
+	DefaultParameters:
+	{
+		GridSize: 20
+	},
+
+	ParameterSchema:
+	{
+		GridSize: { Type: 'PreciseNumber', Label: 'Grid size', Default: 20, Min: 1, Max: 200 }
+	}
+};

package/source/providers/edges/Edge-Perimeter-Linear.js

@@ -0,0 +1,31 @@
+const libPerimeterMath = require('./Edge-PerimeterMath.js');
+
+/**
+ * Edge-Perimeter-Linear
+ *
+ * Perimeter attachment + literal straight line between the two
+ * resolved exit points. Reads cleanly for force-directed and circular
+ * layouts where the topology already determines edge angles, and the
+ * curves of bezier add visual noise.
+ */
+module.exports =
+{
+	Name: 'Perimeter-Linear',
+	Label: 'Perimeter (linear)',
+	Description: 'Each connection exits the node at the perimeter, then runs as a straight line to the other end.',
+
+	GeneratePath: function (pContext)
+	{
+		let tmpS = pContext.Source;
+		let tmpT = pContext.Target;
+		return `M ${tmpS.x} ${tmpS.y} L ${tmpT.x} ${tmpT.y}`;
+	},
+
+	ResolveAttachment: function (pContext)
+	{
+		return libPerimeterMath.resolvePerimeterAttachment(pContext);
+	},
+
+	DefaultParameters: {},
+	ParameterSchema: {}
+};

package/source/providers/edges/Edge-Perimeter-Orthogonal.js

@@ -0,0 +1,39 @@
+const libPerimeterMath = require('./Edge-PerimeterMath.js');
+
+/**
+ * Edge-Perimeter-Orthogonal
+ *
+ * Perimeter attachment + right-angle (Manhattan) routing between
+ * the two resolved exit points. Best when the layout already has
+ * grid-like structure (Grid, Mesh) and you want connections to
+ * leave from whichever side faces the partner.
+ */
+module.exports =
+{
+	Name: 'Perimeter-Orthogonal',
+	Label: 'Perimeter (orthogonal)',
+	Description: 'Each connection exits the node at the perimeter, then routes via right-angle segments to the other end.',
+
+	GeneratePath: function (pContext)
+	{
+		let tmpData = (pContext.Connection && pContext.Connection.Data) || {};
+		let tmpCorners = null;
+		if (tmpData.HandleCustomized && tmpData.OrthoCorner1X != null)
+		{
+			tmpCorners =
+			{
+				corner1: { x: tmpData.OrthoCorner1X, y: tmpData.OrthoCorner1Y },
+				corner2: { x: tmpData.OrthoCorner2X, y: tmpData.OrthoCorner2Y }
+			};
+		}
+		return pContext.Helpers.generateOrthogonal(pContext.Source, pContext.Target, tmpCorners, tmpData.OrthoMidOffset || 0);
+	},
+
+	ResolveAttachment: function (pContext)
+	{
+		return libPerimeterMath.resolvePerimeterAttachment(pContext);
+	},
+
+	DefaultParameters: {},
+	ParameterSchema: {}
+};

package/source/providers/edges/Edge-Perimeter.js

@@ -0,0 +1,48 @@
+const libPerimeterMath = require('./Edge-PerimeterMath.js');
+
+/**
+ * Edge-Perimeter (Bezier)
+ *
+ * "Smart exit" routing with smooth bezier curves. Each connection
+ * exits the node at the perimeter point closest to its target —
+ * solves star/hub topologies where many connections share one port.
+ *
+ * Renders the path as a side-aware bezier (uses the side returned by
+ * `ResolveAttachment` so the curve departs in the right direction).
+ *
+ * See `Edge-Perimeter-Linear` and `Edge-Perimeter-Orthogonal` for the
+ * straight-line and right-angle variants.
+ */
+module.exports =
+{
+	Name: 'Perimeter',
+	Label: 'Perimeter (bezier)',
+	Description: 'Each connection exits the node at the perimeter point closest to its target, with smooth bezier curves. Fixes star/hub topologies where many lines share one port.',
+
+	GeneratePath: function (pContext)
+	{
+		// Honor user-edited bezier handles when the connection is selected
+		// and dragged. Without this, the drag handles render but moving
+		// them does nothing because Perimeter would always re-emit a
+		// fresh side-aware bezier.
+		let tmpHelpers = pContext.Helpers;
+		let tmpData = (pContext.Connection && pContext.Connection.Data) || {};
+		if (tmpData.HandleCustomized)
+		{
+			let tmpHandles = tmpHelpers.getBezierHandles(tmpData);
+			if (tmpHandles.length > 0)
+			{
+				return tmpHelpers.generateMultiBezier(pContext.Source, pContext.Target, tmpHandles);
+			}
+		}
+		return tmpHelpers.generateBezier(pContext.Source, pContext.Target);
+	},
+
+	ResolveAttachment: function (pContext)
+	{
+		return libPerimeterMath.resolvePerimeterAttachment(pContext);
+	},
+
+	DefaultParameters: {},
+	ParameterSchema: {}
+};

package/source/providers/edges/Edge-PerimeterMath.js

@@ -0,0 +1,92 @@
+/**
+ * Edge-PerimeterMath
+ *
+ * Shared geometry helper for the Perimeter family of edge themes
+ * (Perimeter, Perimeter-Linear, Perimeter-Orthogonal). Solves the
+ * "where on this node's bounding box should the line attach so it
+ * points at the other end" question.
+ *
+ * The themes themselves only differ in how they render the path
+ * between the two attachment points; the attachment math is identical.
+ */
+
+/**
+ * Resolve a perimeter attachment point for one end of a connection.
+ * Traces a line from the node's center toward the other end and returns
+ * the first crossing of the node's bounding-box perimeter, plus the
+ * `side` of that crossing (so the bezier helper departs in the right
+ * direction).
+ *
+ * @param {Object} pContext - the same shape the renderer passes into
+ *        ResolveAttachment (Node, OtherNode, OtherDefaultPosition,
+ *        DefaultPosition, …).
+ * @returns {{x: number, y: number, side: string}|Object|null}
+ *        Returns null when node geometry is missing; returns
+ *        DefaultPosition (verbatim) for degenerate same-center cases.
+ */
+function _resolvePerimeterAttachment(pContext)
+{
+	let tmpNode = pContext.Node;
+	if (!tmpNode || typeof tmpNode.X !== 'number' || typeof tmpNode.Y !== 'number') return null;
+
+	let tmpW = tmpNode.Width || 180;
+	let tmpH = tmpNode.Height || 80;
+	let tmpCx = tmpNode.X + tmpW / 2;
+	let tmpCy = tmpNode.Y + tmpH / 2;
+
+	let tmpAimX, tmpAimY;
+	if (pContext.OtherNode && typeof pContext.OtherNode.X === 'number')
+	{
+		let tmpOW = pContext.OtherNode.Width || 180;
+		let tmpOH = pContext.OtherNode.Height || 80;
+		tmpAimX = pContext.OtherNode.X + tmpOW / 2;
+		tmpAimY = pContext.OtherNode.Y + tmpOH / 2;
+	}
+	else if (pContext.OtherDefaultPosition)
+	{
+		tmpAimX = pContext.OtherDefaultPosition.x;
+		tmpAimY = pContext.OtherDefaultPosition.y;
+	}
+	else
+	{
+		return null;
+	}
+
+	let tmpDX = tmpAimX - tmpCx;
+	let tmpDY = tmpAimY - tmpCy;
+
+	if (tmpDX === 0 && tmpDY === 0) return pContext.DefaultPosition || null;
+
+	let tmpHalfW = tmpW / 2;
+	let tmpHalfH = tmpH / 2;
+
+	let tmpTX = (tmpDX > 0) ? tmpHalfW / tmpDX
+		: (tmpDX < 0) ? -tmpHalfW / tmpDX
+		: Infinity;
+	let tmpTY = (tmpDY > 0) ? tmpHalfH / tmpDY
+		: (tmpDY < 0) ? -tmpHalfH / tmpDY
+		: Infinity;
+
+	let tmpT, tmpSide;
+	if (tmpTX < tmpTY)
+	{
+		tmpT = tmpTX;
+		tmpSide = (tmpDX > 0) ? 'right' : 'left';
+	}
+	else
+	{
+		tmpT = tmpTY;
+		tmpSide = (tmpDY > 0) ? 'bottom' : 'top';
+	}
+
+	return {
+		x: tmpCx + tmpT * tmpDX,
+		y: tmpCy + tmpT * tmpDY,
+		side: tmpSide
+	};
+}
+
+module.exports =
+{
+	resolvePerimeterAttachment: _resolvePerimeterAttachment
+};

package/source/providers/edges/Edge-Straight.js

@@ -0,0 +1,24 @@
+/**
+ * Edge-Straight
+ *
+ * Literal straight line from source port to target port. Useful for
+ * dense clusters where curves add visual noise, and for force-directed
+ * layouts where the topology already determines edge angles.
+ */
+module.exports =
+{
+	Name: 'Straight',
+	Label: 'Straight line',
+	Description: 'Plain straight line between ports.',
+
+	GeneratePath: function (pContext)
+	{
+		let tmpSrc = pContext.Source;
+		let tmpTgt = pContext.Target;
+		return `M ${tmpSrc.x} ${tmpSrc.y} L ${tmpTgt.x} ${tmpTgt.y}`;
+	},
+
+	DefaultParameters: {},
+
+	ParameterSchema: {}
+};

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

@@ -0,0 +1,203 @@
+const libCoerce = require('./Layout-Coerce.js');
+
+/**
+ * Layout-Circular
+ *
+ * Concentric-ring layout.
+ *
+ * Two modes, decided by the presence of connections:
+ *
+ *   With connections: BFS from the root nodes (in-degree 0; or all
+ *   nodes if every node has incoming edges). Each BFS depth becomes
+ *   one ring. Roots cluster near the center, leaves on the outer rings.
+ *
+ *   Without connections: all nodes share a single ring with equal
+ *   angular spacing.
+ *
+ * Within each ring, nodes are placed at equal angles starting from
+ * `StartAngle` (in degrees, 0 = +X axis), going clockwise or
+ * counter-clockwise per `Direction`.
+ */
+module.exports =
+{
+	Name: 'Circular',
+	Label: 'Circular',
+	Description: 'Concentric rings; uses connections for ring assignment when available.',
+	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 tmpCenterX     = libCoerce.toFloat(tmpParams.CenterX, 1000);
+		let tmpCenterY     = libCoerce.toFloat(tmpParams.CenterY, 750);
+		let tmpRingSpacing = libCoerce.toFloat(tmpParams.RingSpacing, 220) * tmpSpacing;
+		let tmpInnerRadius = libCoerce.toFloat(tmpParams.InnerRadius, 0) * tmpSpacing;
+		let tmpStartAngle  = libCoerce.toFloat(tmpParams.StartAngle, -90);
+		let tmpDirection   = (tmpParams.Direction === 'ccw') ? 'ccw' : 'cw';
+
+		let tmpConnections = Array.isArray(pConnections) ? pConnections : [];
+
+		// Build in-degree map and adjacency
+		let tmpInDegree = {};
+		let tmpAdjacency = {};
+		let tmpNodeMap = {};
+		for (let i = 0; i < pNodes.length; i++)
+		{
+			tmpNodeMap[pNodes[i].Hash] = pNodes[i];
+			tmpInDegree[pNodes[i].Hash] = 0;
+			tmpAdjacency[pNodes[i].Hash] = [];
+		}
+		for (let i = 0; i < tmpConnections.length; i++)
+		{
+			let tmpConn = tmpConnections[i];
+			if (tmpInDegree.hasOwnProperty(tmpConn.TargetNodeHash))
+			{
+				tmpInDegree[tmpConn.TargetNodeHash]++;
+			}
+			if (tmpAdjacency.hasOwnProperty(tmpConn.SourceNodeHash))
+			{
+				tmpAdjacency[tmpConn.SourceNodeHash].push(tmpConn.TargetNodeHash);
+			}
+		}
+
+		// Identify roots
+		let tmpRoots = [];
+		for (let i = 0; i < pNodes.length; i++)
+		{
+			if (tmpInDegree[pNodes[i].Hash] === 0)
+			{
+				tmpRoots.push(pNodes[i].Hash);
+			}
+		}
+
+		let tmpRings = [];
+
+		if (tmpConnections.length === 0 || tmpRoots.length === 0)
+		{
+			tmpRings.push(pNodes.map((pNode) => pNode.Hash));
+		}
+		else
+		{
+			// BFS by depth
+			let tmpVisited = {};
+			let tmpCurrent = tmpRoots.slice();
+			while (tmpCurrent.length > 0)
+			{
+				let tmpRing = [];
+				let tmpNext = [];
+				for (let i = 0; i < tmpCurrent.length; i++)
+				{
+					let tmpHash = tmpCurrent[i];
+					if (tmpVisited[tmpHash]) continue;
+					tmpVisited[tmpHash] = true;
+					tmpRing.push(tmpHash);
+
+					let tmpChildren = tmpAdjacency[tmpHash] || [];
+					for (let j = 0; j < tmpChildren.length; j++)
+					{
+						if (!tmpVisited[tmpChildren[j]])
+						{
+							tmpNext.push(tmpChildren[j]);
+						}
+					}
+				}
+				if (tmpRing.length > 0) tmpRings.push(tmpRing);
+				tmpCurrent = tmpNext;
+			}
+
+			let tmpRemaining = [];
+			for (let i = 0; i < pNodes.length; i++)
+			{
+				if (!tmpVisited[pNodes[i].Hash]) tmpRemaining.push(pNodes[i].Hash);
+			}
+			if (tmpRemaining.length > 0) tmpRings.push(tmpRemaining);
+		}
+
+		// Place nodes
+		let tmpAngleSign = (tmpDirection === 'cw') ? 1 : -1;
+		let tmpStartRad = tmpStartAngle * Math.PI / 180;
+
+		for (let tmpRingIdx = 0; tmpRingIdx < tmpRings.length; tmpRingIdx++)
+		{
+			let tmpRing = tmpRings[tmpRingIdx];
+			let tmpRadius = tmpInnerRadius + tmpRingIdx * tmpRingSpacing;
+
+			if (tmpRing.length === 1 && tmpRingIdx === 0 && tmpInnerRadius === 0)
+			{
+				let tmpNode = tmpNodeMap[tmpRing[0]];
+				if (tmpNode)
+				{
+					tmpNode.X = tmpCenterX - (tmpNode.Width || 180) / 2;
+					tmpNode.Y = tmpCenterY - (tmpNode.Height || 80) / 2;
+				}
+				continue;
+			}
+
+			let tmpAngleStep = (2 * Math.PI) / tmpRing.length;
+			for (let i = 0; i < tmpRing.length; i++)
+			{
+				let tmpNode = tmpNodeMap[tmpRing[i]];
+				if (!tmpNode) continue;
+				let tmpAngle = tmpStartRad + tmpAngleSign * i * tmpAngleStep;
+				let tmpW = tmpNode.Width || 180;
+				let tmpH = tmpNode.Height || 80;
+				tmpNode.X = tmpCenterX + Math.cos(tmpAngle) * tmpRadius - tmpW / 2;
+				tmpNode.Y = tmpCenterY + Math.sin(tmpAngle) * tmpRadius - tmpH / 2;
+			}
+		}
+	},
+
+	DefaultParameters:
+	{
+		Spacing: 1.0,
+		CenterX: 1000,
+		CenterY: 750,
+		RingSpacing: 220,
+		InnerRadius: 0,
+		StartAngle: -90,
+		Direction: 'cw'
+	},
+
+	ParameterSchema:
+	{
+		Spacing:     { Type: 'PreciseNumber', Label: 'Spacing (multiplier)', Default: 1.0, Min: 0.1, Max: 5 },
+		CenterX:     { Type: 'PreciseNumber', Label: 'Center X',     Default: 1000, Min: -10000, Max: 10000 },
+		CenterY:     { Type: 'PreciseNumber', Label: 'Center Y',     Default: 750,  Min: -10000, Max: 10000 },
+		RingSpacing: { Type: 'PreciseNumber', Label: 'Ring spacing', Default: 220,  Min: 1, Max: 5000 },
+		InnerRadius: { Type: 'PreciseNumber', Label: 'Inner radius', Default: 0,    Min: 0, Max: 5000 },
+		StartAngle:  { Type: 'PreciseNumber', Label: 'Start angle (deg)', Default: -90, Min: -360, Max: 360 },
+		Direction:   { Type: 'enum',          Label: 'Direction',    Default: 'cw', Options: ['cw', 'ccw'] }
+	},
+
+	ParameterManifest:
+	{
+		Scope: 'PictFlowLayout-Circular',
+		Sections:
+		[
+			{ Name: 'Circular Parameters', Hash: 'PFLCircularSection', Groups: [{ Name: 'Defaults', Hash: 'PFLCircularGroup' }] }
+		],
+		Descriptors:
+		{
+			'PictFlowLayoutEditor.Parameters.Spacing':
+			{ Name: 'Spacing (multiplier)', Hash: 'Spacing', DataType: 'PreciseNumber', Default: 1.0, PictForm: { Section: 'PFLCircularSection', Group: 'PFLCircularGroup', Row: 0, Width: 12, Min: 0.1, Max: 5 } },
+			'PictFlowLayoutEditor.Parameters.CenterX':
+			{ Name: 'Center X', Hash: 'CenterX', DataType: 'PreciseNumber', Default: 1000, PictForm: { Section: 'PFLCircularSection', Group: 'PFLCircularGroup', Row: 1, Width: 6, Min: -10000, Max: 10000 } },
+			'PictFlowLayoutEditor.Parameters.CenterY':
+			{ Name: 'Center Y', Hash: 'CenterY', DataType: 'PreciseNumber', Default: 750, PictForm: { Section: 'PFLCircularSection', Group: 'PFLCircularGroup', Row: 1, Width: 6, Min: -10000, Max: 10000 } },
+			'PictFlowLayoutEditor.Parameters.RingSpacing':
+			{ Name: 'Ring spacing', Hash: 'RingSpacing', DataType: 'PreciseNumber', Default: 220, PictForm: { Section: 'PFLCircularSection', Group: 'PFLCircularGroup', Row: 2, Width: 6, Min: 1, Max: 5000 } },
+			'PictFlowLayoutEditor.Parameters.InnerRadius':
+			{ Name: 'Inner radius', Hash: 'InnerRadius', DataType: 'PreciseNumber', Default: 0, PictForm: { Section: 'PFLCircularSection', Group: 'PFLCircularGroup', Row: 2, Width: 6, Min: 0, Max: 5000 } },
+			'PictFlowLayoutEditor.Parameters.StartAngle':
+			{ Name: 'Start angle (deg)', Hash: 'StartAngle', DataType: 'PreciseNumber', Default: -90, PictForm: { Section: 'PFLCircularSection', Group: 'PFLCircularGroup', Row: 3, Width: 6, Min: -360, Max: 360 } },
+			'PictFlowLayoutEditor.Parameters.Direction':
+			{
+				Name: 'Direction', Hash: 'Direction', DataType: 'String', Default: 'cw',
+				PictForm: { Section: 'PFLCircularSection', Group: 'PFLCircularGroup', Row: 3, Width: 6, InputType: 'Option', SelectOptions: [{ Value: 'cw', Name: 'Clockwise' }, { Value: 'ccw', Name: 'Counter-clockwise' }] }
+			}
+		}
+	}
+};

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

@@ -0,0 +1,40 @@
+/**
+ * Layout-Coerce
+ *
+ * Tiny coercion helpers for layout-algorithm parameters. Manyfest's
+ * `PreciseNumber` DataType stores values as strings (so big.js /
+ * fable.ExpressionParser can do arbitrary-precision math on them
+ * without float drift). The simulation code in each layout algorithm
+ * uses native JS Math, so we coerce at the entry point.
+ *
+ * Apply functions accept either format (number or string) and use
+ * these helpers to normalize.
+ */
+
+function _toFloat(pValue, pDefault)
+{
+	if (typeof pValue === 'number' && !isNaN(pValue)) return pValue;
+	if (typeof pValue === 'string' && pValue !== '')
+	{
+		let tmpNum = parseFloat(pValue);
+		if (!isNaN(tmpNum)) return tmpNum;
+	}
+	return pDefault;
+}
+
+function _toInt(pValue, pDefault)
+{
+	if (typeof pValue === 'number' && !isNaN(pValue)) return Math.floor(pValue);
+	if (typeof pValue === 'string' && pValue !== '')
+	{
+		let tmpNum = parseInt(pValue, 10);
+		if (!isNaN(tmpNum)) return tmpNum;
+	}
+	return pDefault;
+}
+
+module.exports =
+{
+	toFloat: _toFloat,
+	toInt: _toInt
+};