pict-section-flow 0.0.16 → 0.0.18

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

@@ -0,0 +1,134 @@
+const libCoerce = require('./Layout-Coerce.js');
+
+/**
+ * Layout-Columnar
+ *
+ * N-column layout with deterministic fill order. Distinct from Grid in
+ * two ways:
+ *   - Columns is always explicit (no 'auto')
+ *   - FillOrder controls whether nodes flow row-first or column-first
+ *
+ * The column count is `Number` (integer index); spacing/origin values
+ * are `PreciseNumber` so they survive solver chains.
+ */
+module.exports =
+{
+	Name: 'Columnar',
+	Label: 'Columnar (N Columns)',
+	Description: 'Explicit N columns; flow row-first or column-first.',
+	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 tmpColumns         = Math.max(1, libCoerce.toInt(tmpParams.Columns, 3));
+		let tmpColumnSpacing   = libCoerce.toFloat(tmpParams.ColumnSpacing, 40) * tmpSpacing;
+		let tmpRowSpacing      = libCoerce.toFloat(tmpParams.RowSpacing, 40) * tmpSpacing;
+		let tmpStartX          = libCoerce.toFloat(tmpParams.StartX, 100);
+		let tmpStartY          = libCoerce.toFloat(tmpParams.StartY, 100);
+		let tmpFillOrder       = (tmpParams.FillOrder === 'column') ? 'column' : 'row';
+		let tmpOrderBy         = tmpParams.OrderBy || 'index';
+
+		// Compute cell dimensions from largest node
+		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  = tmpMaxWidth + tmpColumnSpacing;
+		let tmpCellHeight = tmpMaxHeight + tmpRowSpacing;
+
+		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 tmpRows = Math.ceil(tmpOrdered.length / tmpColumns);
+
+		for (let i = 0; i < tmpOrdered.length; i++)
+		{
+			let tmpRow;
+			let tmpCol;
+			if (tmpFillOrder === 'column')
+			{
+				tmpCol = Math.floor(i / tmpRows);
+				tmpRow = i % tmpRows;
+			}
+			else
+			{
+				tmpRow = Math.floor(i / tmpColumns);
+				tmpCol = i % tmpColumns;
+			}
+			tmpOrdered[i].X = tmpStartX + tmpCol * tmpCellWidth;
+			tmpOrdered[i].Y = tmpStartY + tmpRow * tmpCellHeight;
+		}
+	},
+
+	DefaultParameters:
+	{
+		Spacing: 1.0,
+		Columns: 3,
+		ColumnSpacing: 40,
+		RowSpacing: 40,
+		StartX: 100,
+		StartY: 100,
+		FillOrder: 'row',
+		OrderBy: 'index'
+	},
+
+	ParameterSchema:
+	{
+		Spacing:       { Type: 'PreciseNumber', Label: 'Spacing (multiplier)', Default: 1.0, Min: 0.1, Max: 5 },
+		Columns:       { Type: 'Number',        Label: 'Columns',        Default: 3,   Min: 1, Max: 50 },
+		ColumnSpacing: { Type: 'PreciseNumber', Label: 'Column spacing', Default: 40,  Min: 0, Max: 1000 },
+		RowSpacing:    { Type: 'PreciseNumber', Label: 'Row spacing',    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 },
+		FillOrder:     { Type: 'enum',          Label: 'Fill order',     Default: 'row', Options: ['row', 'column'] },
+		OrderBy:       { Type: 'enum',          Label: 'Order by',       Default: 'index', Options: ['index', 'hash', 'title'] }
+	},
+
+	ParameterManifest:
+	{
+		Scope: 'PictFlowLayout-Columnar',
+		Sections:
+		[
+			{ Name: 'Columnar Parameters', Hash: 'PFLColumnarSection', Groups: [{ Name: 'Defaults', Hash: 'PFLColumnarGroup' }] }
+		],
+		Descriptors:
+		{
+			'PictFlowLayoutEditor.Parameters.Spacing':
+			{ Name: 'Spacing (multiplier)', Hash: 'Spacing', DataType: 'PreciseNumber', Default: 1.0, PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 0, Width: 12, Min: 0.1, Max: 5 } },
+			'PictFlowLayoutEditor.Parameters.Columns':
+			{ Name: 'Columns', Hash: 'Columns', DataType: 'Number', Default: 3, PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 1, Width: 6, Min: 1, Max: 50 } },
+			'PictFlowLayoutEditor.Parameters.FillOrder':
+			{
+				Name: 'Fill order', Hash: 'FillOrder', DataType: 'String', Default: 'row',
+				PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 1, Width: 6, InputType: 'Option', SelectOptions: [{ Value: 'row', Name: 'Row-first' }, { Value: 'column', Name: 'Column-first' }] }
+			},
+			'PictFlowLayoutEditor.Parameters.ColumnSpacing':
+			{ Name: 'Column spacing', Hash: 'ColumnSpacing', DataType: 'PreciseNumber', Default: 40, PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 2, Width: 6, Min: 0, Max: 1000 } },
+			'PictFlowLayoutEditor.Parameters.RowSpacing':
+			{ Name: 'Row spacing', Hash: 'RowSpacing', DataType: 'PreciseNumber', Default: 40, PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 2, Width: 6, Min: 0, Max: 1000 } },
+			'PictFlowLayoutEditor.Parameters.StartX':
+			{ Name: 'Start X', Hash: 'StartX', DataType: 'PreciseNumber', Default: 100, PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 3, Width: 6, Min: -10000, Max: 10000 } },
+			'PictFlowLayoutEditor.Parameters.StartY':
+			{ Name: 'Start Y', Hash: 'StartY', DataType: 'PreciseNumber', Default: 100, PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 3, Width: 6, Min: -10000, Max: 10000 } },
+			'PictFlowLayoutEditor.Parameters.OrderBy':
+			{
+				Name: 'Order by', Hash: 'OrderBy', DataType: 'String', Default: 'index',
+				PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 4, Width: 12, InputType: 'Option', SelectOptions: [{ Value: 'index', Name: 'Index' }, { Value: 'hash', Name: 'Hash' }, { Value: 'title', Name: 'Title' }] }
+			}
+		}
+	}
+};

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

@@ -0,0 +1,27 @@
+/**
+ * Layout-Custom
+ *
+ * No-op layout algorithm. Preserves the X/Y values currently on each
+ * node so users can hand-place nodes without an algorithm clobbering
+ * positions on the next render.
+ *
+ * Selecting "Custom" with auto-apply enabled is effectively a no-op
+ * on every structural change — useful as a way to disable the
+ * configured algorithm without unsetting it.
+ */
+module.exports =
+{
+	Name: 'Custom',
+	Label: 'Custom (Hand-placed)',
+	Description: 'Preserve hand-placed positions. No automatic arrangement.',
+	DefaultEdgeTheme: 'Bezier',
+
+	Apply: function (pNodes, pConnections, pParameters)
+	{
+		// Intentionally empty — Custom is a no-op.
+	},
+
+	DefaultParameters: {},
+
+	ParameterSchema: {}
+};

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

@@ -0,0 +1,256 @@
+const libCoerce = require('./Layout-Coerce.js');
+
+/**
+ * Layout-ForcedFromCenter
+ *
+ * Force-directed simulation in the Fruchterman-Reingold style:
+ *   - Spring (attractive) forces along each connection
+ *   - Coulomb-style repulsion between every pair of nodes
+ *   - Center-attraction force pulling all nodes toward (CenterX, CenterY)
+ *   - Cooling schedule: max displacement per iteration shrinks over time
+ *
+ * Deterministic by default — initial positions for unplaced nodes are
+ * generated from a seedable Mulberry32 PRNG (inline implementation, no
+ * new dependencies). Tests pin `Seed` to assert byte-identical output.
+ *
+ * Performance: O(n^2) per iteration. With Iterations=200 this is fine
+ * for ~100 nodes; keep ForcedFromCenter for moderate-sized graphs.
+ *
+ * Numeric parameters (other than Iterations and Seed) are typed
+ * `PreciseNumber` so they round-trip cleanly through the
+ * ExpressionParser; the simulation coerces back to JS floats via
+ * Layout-Coerce. Iterations and Seed stay `Number` because they're
+ * loop counters / bitwise-PRNG state.
+ */
+module.exports =
+{
+	Name: 'ForcedFromCenter',
+	Label: 'Forced from Center',
+	Description: 'Spring + repulsion simulation pulling toward a center point.',
+	DefaultEdgeTheme: 'Bezier',
+
+	Apply: function (pNodes, pConnections, pParameters)
+	{
+		if (!pNodes || pNodes.length === 0) return;
+
+		let tmpParams = pParameters || {};
+		let tmpSpacing            = libCoerce.toFloat(tmpParams.Spacing,            1.0);
+		let tmpIterations         = libCoerce.toInt(tmpParams.Iterations,         200);
+		let tmpCenterX            = libCoerce.toFloat(tmpParams.CenterX,            1000);
+		let tmpCenterY            = libCoerce.toFloat(tmpParams.CenterY,            750);
+		let tmpSpringLength       = libCoerce.toFloat(tmpParams.SpringLength,       200) * tmpSpacing;
+		let tmpSpringStiffness    = libCoerce.toFloat(tmpParams.SpringStiffness,    0.05);
+		let tmpRepulsion          = libCoerce.toFloat(tmpParams.Repulsion,          8000);
+		let tmpCenterAttraction   = libCoerce.toFloat(tmpParams.CenterAttraction,   0.01);
+		let tmpCoolingFactor      = libCoerce.toFloat(tmpParams.CoolingFactor,      0.95);
+		let tmpInitialTemperature = libCoerce.toFloat(tmpParams.InitialTemperature, 100);
+		let tmpSeed               = libCoerce.toInt(tmpParams.Seed,               42);
+		let tmpPreservePositions  = !!tmpParams.PreservePositions;
+		let tmpInitialSpread      = libCoerce.toFloat(tmpParams.InitialSpread,      400);
+
+		let tmpConnections = Array.isArray(pConnections) ? pConnections : [];
+
+		// Mulberry32 seeded PRNG — deterministic initial-position generator.
+		let tmpRand = _makeMulberry32(tmpSeed >>> 0);
+
+		// Initial positions
+		for (let i = 0; i < pNodes.length; i++)
+		{
+			let tmpNode = pNodes[i];
+			let tmpHasPosition = (typeof tmpNode.X === 'number' && typeof tmpNode.Y === 'number');
+			if (tmpPreservePositions && tmpHasPosition) continue;
+			tmpNode.X = tmpCenterX + (tmpRand() - 0.5) * tmpInitialSpread;
+			tmpNode.Y = tmpCenterY + (tmpRand() - 0.5) * tmpInitialSpread;
+		}
+
+		// Index nodes by hash for connection lookup
+		let tmpNodeMap = {};
+		for (let i = 0; i < pNodes.length; i++)
+		{
+			tmpNodeMap[pNodes[i].Hash] = pNodes[i];
+		}
+
+		let tmpTemperature = tmpInitialTemperature;
+
+		for (let tmpIter = 0; tmpIter < tmpIterations; tmpIter++)
+		{
+			// Force accumulators
+			let tmpForceX = new Array(pNodes.length).fill(0);
+			let tmpForceY = new Array(pNodes.length).fill(0);
+
+			// Repulsion between every pair of nodes
+			for (let i = 0; i < pNodes.length; i++)
+			{
+				let tmpA = pNodes[i];
+				for (let j = i + 1; j < pNodes.length; j++)
+				{
+					let tmpB = pNodes[j];
+					let tmpDX = tmpA.X - tmpB.X;
+					let tmpDY = tmpA.Y - tmpB.Y;
+					let tmpDistSq = tmpDX * tmpDX + tmpDY * tmpDY;
+					if (tmpDistSq < 1) tmpDistSq = 1; // avoid singularities
+					let tmpDist = Math.sqrt(tmpDistSq);
+					let tmpForce = tmpRepulsion / tmpDistSq;
+					let tmpFX = (tmpDX / tmpDist) * tmpForce;
+					let tmpFY = (tmpDY / tmpDist) * tmpForce;
+					tmpForceX[i] += tmpFX;
+					tmpForceY[i] += tmpFY;
+					tmpForceX[j] -= tmpFX;
+					tmpForceY[j] -= tmpFY;
+				}
+			}
+
+			// Spring forces along connections
+			for (let i = 0; i < tmpConnections.length; i++)
+			{
+				let tmpConn = tmpConnections[i];
+				let tmpSource = tmpNodeMap[tmpConn.SourceNodeHash];
+				let tmpTarget = tmpNodeMap[tmpConn.TargetNodeHash];
+				if (!tmpSource || !tmpTarget) continue;
+
+				let tmpSourceIdx = pNodes.indexOf(tmpSource);
+				let tmpTargetIdx = pNodes.indexOf(tmpTarget);
+				if (tmpSourceIdx < 0 || tmpTargetIdx < 0) continue;
+
+				let tmpDX = tmpTarget.X - tmpSource.X;
+				let tmpDY = tmpTarget.Y - tmpSource.Y;
+				let tmpDist = Math.sqrt(tmpDX * tmpDX + tmpDY * tmpDY);
+				if (tmpDist < 0.0001) tmpDist = 0.0001;
+
+				let tmpDelta = tmpDist - tmpSpringLength;
+				let tmpForce = tmpSpringStiffness * tmpDelta;
+				let tmpFX = (tmpDX / tmpDist) * tmpForce;
+				let tmpFY = (tmpDY / tmpDist) * tmpForce;
+
+				tmpForceX[tmpSourceIdx] += tmpFX;
+				tmpForceY[tmpSourceIdx] += tmpFY;
+				tmpForceX[tmpTargetIdx] -= tmpFX;
+				tmpForceY[tmpTargetIdx] -= tmpFY;
+			}
+
+			// Center attraction
+			for (let i = 0; i < pNodes.length; i++)
+			{
+				let tmpNode = pNodes[i];
+				tmpForceX[i] += (tmpCenterX - tmpNode.X) * tmpCenterAttraction;
+				tmpForceY[i] += (tmpCenterY - tmpNode.Y) * tmpCenterAttraction;
+			}
+
+			// Apply forces with temperature clamp
+			for (let i = 0; i < pNodes.length; i++)
+			{
+				let tmpNode = pNodes[i];
+				let tmpFX = tmpForceX[i];
+				let tmpFY = tmpForceY[i];
+				let tmpMag = Math.sqrt(tmpFX * tmpFX + tmpFY * tmpFY);
+				if (tmpMag > tmpTemperature)
+				{
+					tmpFX = (tmpFX / tmpMag) * tmpTemperature;
+					tmpFY = (tmpFY / tmpMag) * tmpTemperature;
+				}
+				tmpNode.X += tmpFX;
+				tmpNode.Y += tmpFY;
+			}
+
+			tmpTemperature *= tmpCoolingFactor;
+		}
+
+		// Round to whole pixels for stable rendering and predictable tests
+		for (let i = 0; i < pNodes.length; i++)
+		{
+			pNodes[i].X = Math.round(pNodes[i].X);
+			pNodes[i].Y = Math.round(pNodes[i].Y);
+		}
+	},
+
+	DefaultParameters:
+	{
+		Spacing: 1.0,
+		Iterations: 200,
+		CenterX: 1000,
+		CenterY: 750,
+		SpringLength: 200,
+		SpringStiffness: 0.05,
+		Repulsion: 8000,
+		CenterAttraction: 0.01,
+		CoolingFactor: 0.95,
+		InitialTemperature: 100,
+		Seed: 42,
+		PreservePositions: false,
+		InitialSpread: 400
+	},
+
+	ParameterSchema:
+	{
+		Spacing:            { Type: 'PreciseNumber', Label: 'Spacing (multiplier)', Default: 1.0, Min: 0.1, Max: 5 },
+		Iterations:         { Type: 'Number',        Label: 'Iterations',         Default: 200,   Min: 1,    Max: 2000  },
+		CenterX:            { Type: 'PreciseNumber', Label: 'Center X',           Default: 1000,  Min: -10000, Max: 10000 },
+		CenterY:            { Type: 'PreciseNumber', Label: 'Center Y',           Default: 750,   Min: -10000, Max: 10000 },
+		SpringLength:       { Type: 'PreciseNumber', Label: 'Spring length',      Default: 200,   Min: 1,    Max: 2000  },
+		SpringStiffness:    { Type: 'PreciseNumber', Label: 'Spring stiffness',   Default: 0.05,  Min: 0,    Max: 1     },
+		Repulsion:          { Type: 'PreciseNumber', Label: 'Repulsion',          Default: 8000,  Min: 0,    Max: 100000 },
+		CenterAttraction:   { Type: 'PreciseNumber', Label: 'Center attraction',  Default: 0.01,  Min: 0,    Max: 1     },
+		CoolingFactor:      { Type: 'PreciseNumber', Label: 'Cooling factor',     Default: 0.95,  Min: 0.5,  Max: 1     },
+		InitialTemperature: { Type: 'PreciseNumber', Label: 'Initial temperature', Default: 100,  Min: 1,    Max: 1000  },
+		Seed:               { Type: 'Number',        Label: 'Random seed',        Default: 42,    Min: 0,    Max: 2147483647 },
+		PreservePositions:  { Type: 'boolean',       Label: 'Preserve positions', Default: false },
+		InitialSpread:      { Type: 'PreciseNumber', Label: 'Initial spread',     Default: 400,   Min: 0,    Max: 5000  }
+	},
+
+	ParameterManifest:
+	{
+		Scope: 'PictFlowLayout-ForcedFromCenter',
+		Sections:
+		[
+			{ Name: 'Center', Hash: 'PFLCenterSection', Groups: [{ Name: 'Defaults', Hash: 'PFLCenterGroup' }] },
+			{ Name: 'Forces', Hash: 'PFLForcesSection', Groups: [{ Name: 'Defaults', Hash: 'PFLForcesGroup' }] },
+			{ Name: 'Simulation', Hash: 'PFLSimSection', Groups: [{ Name: 'Defaults', Hash: 'PFLSimGroup' }] },
+			{ Name: 'Initialization', Hash: 'PFLInitSection', Groups: [{ Name: 'Defaults', Hash: 'PFLInitGroup' }] }
+		],
+		Descriptors:
+		{
+			'PictFlowLayoutEditor.Parameters.Spacing':
+			{ Name: 'Spacing (multiplier)', Hash: 'Spacing', DataType: 'PreciseNumber', Default: 1.0, PictForm: { Section: 'PFLCenterSection', Group: 'PFLCenterGroup', Row: 0, Width: 12, Min: 0.1, Max: 5 } },
+			'PictFlowLayoutEditor.Parameters.CenterX':
+			{ Name: 'Center X', Hash: 'CenterX', DataType: 'PreciseNumber', Default: 1000, PictForm: { Section: 'PFLCenterSection', Group: 'PFLCenterGroup', Row: 1, Width: 6, Min: -10000, Max: 10000 } },
+			'PictFlowLayoutEditor.Parameters.CenterY':
+			{ Name: 'Center Y', Hash: 'CenterY', DataType: 'PreciseNumber', Default: 750, PictForm: { Section: 'PFLCenterSection', Group: 'PFLCenterGroup', Row: 1, Width: 6, Min: -10000, Max: 10000 } },
+			'PictFlowLayoutEditor.Parameters.CenterAttraction':
+			{ Name: 'Center attraction', Hash: 'CenterAttraction', DataType: 'PreciseNumber', Default: 0.01, PictForm: { Section: 'PFLCenterSection', Group: 'PFLCenterGroup', Row: 2, Width: 12, Min: 0, Max: 1 } },
+
+			'PictFlowLayoutEditor.Parameters.SpringLength':
+			{ Name: 'Spring length', Hash: 'SpringLength', DataType: 'PreciseNumber', Default: 200, PictForm: { Section: 'PFLForcesSection', Group: 'PFLForcesGroup', Row: 1, Width: 6, Min: 1, Max: 2000 } },
+			'PictFlowLayoutEditor.Parameters.SpringStiffness':
+			{ Name: 'Spring stiffness', Hash: 'SpringStiffness', DataType: 'PreciseNumber', Default: 0.05, PictForm: { Section: 'PFLForcesSection', Group: 'PFLForcesGroup', Row: 1, Width: 6, Min: 0, Max: 1 } },
+			'PictFlowLayoutEditor.Parameters.Repulsion':
+			{ Name: 'Repulsion', Hash: 'Repulsion', DataType: 'PreciseNumber', Default: 8000, PictForm: { Section: 'PFLForcesSection', Group: 'PFLForcesGroup', Row: 2, Width: 12, Min: 0, Max: 100000 } },
+
+			'PictFlowLayoutEditor.Parameters.Iterations':
+			{ Name: 'Iterations', Hash: 'Iterations', DataType: 'Number', Default: 200, PictForm: { Section: 'PFLSimSection', Group: 'PFLSimGroup', Row: 1, Width: 6, Min: 1, Max: 2000 } },
+			'PictFlowLayoutEditor.Parameters.CoolingFactor':
+			{ Name: 'Cooling factor', Hash: 'CoolingFactor', DataType: 'PreciseNumber', Default: 0.95, PictForm: { Section: 'PFLSimSection', Group: 'PFLSimGroup', Row: 1, Width: 6, Min: 0.5, Max: 1 } },
+			'PictFlowLayoutEditor.Parameters.InitialTemperature':
+			{ Name: 'Initial temperature', Hash: 'InitialTemperature', DataType: 'PreciseNumber', Default: 100, PictForm: { Section: 'PFLSimSection', Group: 'PFLSimGroup', Row: 2, Width: 12, Min: 1, Max: 1000 } },
+
+			'PictFlowLayoutEditor.Parameters.Seed':
+			{ Name: 'Random seed', Hash: 'Seed', DataType: 'Number', Default: 42, PictForm: { Section: 'PFLInitSection', Group: 'PFLInitGroup', Row: 1, Width: 6, Min: 0, Max: 2147483647 } },
+			'PictFlowLayoutEditor.Parameters.InitialSpread':
+			{ Name: 'Initial spread', Hash: 'InitialSpread', DataType: 'PreciseNumber', Default: 400, PictForm: { Section: 'PFLInitSection', Group: 'PFLInitGroup', Row: 1, Width: 6, Min: 0, Max: 5000 } },
+			'PictFlowLayoutEditor.Parameters.PreservePositions':
+			{ Name: 'Preserve existing positions', Hash: 'PreservePositions', DataType: 'Boolean', Default: false, PictForm: { Section: 'PFLInitSection', Group: 'PFLInitGroup', Row: 2, Width: 12, InputType: 'Boolean' } }
+		}
+	}
+};
+
+function _makeMulberry32(pSeed)
+{
+	let tmpState = pSeed >>> 0;
+	return function ()
+	{
+		tmpState = (tmpState + 0x6D2B79F5) >>> 0;
+		let tmpT = tmpState;
+		tmpT = Math.imul(tmpT ^ (tmpT >>> 15), tmpT | 1);
+		tmpT ^= tmpT + Math.imul(tmpT ^ (tmpT >>> 7), tmpT | 61);
+		return ((tmpT ^ (tmpT >>> 14)) >>> 0) / 4294967296;
+	};
+}

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 } }
+		}
+	}
+};