@mstone6969/graph 0.1.0 → 0.2.0

package/dist/charts/diagrams/TopologyLayout.js

@@ -0,0 +1,143 @@
+import { forceCollide, forceLink, forceManyBody, forceSimulation, forceX, forceY, hierarchy, mean, tree } from "d3";
+// src/charts/diagrams/TopologyLayout.ts
+var SWEEPS = 12;
+var RELAX = 8;
+/** Device positions for a network diagram, as index-aligned points whose cells stay inside the area. */
+var TopologyLayout = class TopologyLayout {
+	/**
+	* Layered: `tiers[i]` fixes each device's layer, as in the core, distribution and access model,
+	* and barycentre sweeps (Sugiyama, 1981) order each layer to cut crossings.
+	*/
+	static tiered(tiers, links, area, horizontal) {
+		const levels = [...new Set(tiers)].sort((a, b) => a - b);
+		const layers = levels.map((level) => tiers.flatMap((tier, i) => tier === level ? [i] : []));
+		const near = tiers.map(() => []);
+		for (const [a, b] of links) {
+			near[a].push(b);
+			near[b].push(a);
+		}
+		const place = new Array(tiers.length).fill(0);
+		const stamp = () => layers.forEach((layer) => layer.forEach((device, i) => {
+			place[device] = (i + .5) / layer.length;
+		}));
+		stamp();
+		for (let sweep = 0; sweep < SWEEPS; sweep++) for (const layer of sweep % 2 ? [...layers].reverse() : layers) {
+			const score = new Map(layer.map((device) => [device, mean(near[device].filter((other) => tiers[other] !== tiers[device]).map((other) => place[other])) ?? place[device]]));
+			layer.sort((a, b) => score.get(a) - score.get(b) || a - b);
+			layer.forEach((device, i) => {
+				place[device] = (i + .5) / layer.length;
+			});
+		}
+		const length = horizontal ? area.height : area.width, cell = horizontal ? area.cell.height : area.cell.width;
+		const spread = layers.map((layer) => TopologyLayout.#relax(layer, near, place, tiers, length, cell));
+		const depth = horizontal ? area.width : area.height, step = levels.length ? depth / levels.length : depth;
+		const points = new Array(tiers.length);
+		layers.forEach((layer, l) => layer.forEach((device, i) => {
+			const along = step * (l + .5), across = spread[l][i];
+			points[device] = horizontal ? {
+				x: along,
+				y: across
+			} : {
+				x: across,
+				y: along
+			};
+		}));
+		return points;
+	}
+	/** Slides a layer's devices toward their neighbours without changing their order or closing the gaps. */
+	static #relax(layer, near, place, tiers, length, cell) {
+		const gap = Math.min(length / layer.length, cell + 16), low = cell / 2, high = length - cell / 2;
+		let at = layer.map((_, i) => length * (i + .5) / layer.length);
+		for (let round = 0; round < RELAX; round++) {
+			const wish = layer.map((device, i) => mean(near[device].filter((other) => tiers[other] !== tiers[device]).map((other) => place[other] * length)) ?? at[i]);
+			const up = [...wish], down = [...wish];
+			up[0] = Math.max(up[0], low);
+			for (let i = 1; i < up.length; i++) up[i] = Math.max(up[i], up[i - 1] + gap);
+			down[down.length - 1] = Math.min(down[down.length - 1], high);
+			for (let i = down.length - 2; i >= 0; i--) down[i] = Math.min(down[i], down[i + 1] - gap);
+			at = up.map((value, i) => (value + down[i]) / 2);
+			at[at.length - 1] = Math.min(at[at.length - 1], high);
+			for (let i = at.length - 2; i >= 0; i--) at[i] = Math.min(at[i], at[i + 1] - gap);
+			at[0] = Math.max(at[0], low);
+			for (let i = 1; i < at.length; i++) at[i] = Math.max(at[i], at[i - 1] + gap);
+			layer.forEach((device, i) => {
+				place[device] = at[i] / length;
+			});
+		}
+		return at;
+	}
+	/** Radial tree (Eades, 1992) of the shortest-hop tree from `root`: rings count hops, and each branch gets an arc for its leaves. */
+	static radial(count, links, root, area) {
+		const near = Array.from({ length: count }, () => []);
+		for (const [a, b] of links) {
+			near[a].push(b);
+			near[b].push(a);
+		}
+		const seen = /* @__PURE__ */ new Set();
+		const grow = (start) => {
+			const top = {
+				index: start,
+				children: []
+			}, queue = [top];
+			seen.add(start);
+			while (queue.length) {
+				const at = queue.shift();
+				for (const next of near[at.index]) {
+					if (seen.has(next)) continue;
+					seen.add(next);
+					const child = {
+						index: next,
+						children: []
+					};
+					at.children.push(child);
+					queue.push(child);
+				}
+			}
+			return top;
+		};
+		const crowns = [root, ...Array.from({ length: count }, (_, i) => i)].flatMap((start) => seen.has(start) ? [] : [grow(start)]);
+		const whole = crowns.length === 1 ? crowns[0] : {
+			index: -1,
+			children: crowns
+		};
+		const laid = tree().size([2 * Math.PI, 1]).separation((a, b) => (a.parent === b.parent ? 1 : 2) / Math.max(1, a.depth))(hierarchy(whole, (branch) => branch.children));
+		const rings = Math.max(1, laid.height);
+		const ry = Math.max(1, area.height / 2 - area.cell.height / 2), rx = Math.max(1, area.width / 2 - area.cell.width / 2);
+		const points = new Array(count);
+		for (const node of laid.descendants()) {
+			if (node.data.index < 0) continue;
+			const hop = node.depth / rings;
+			points[node.data.index] = {
+				x: area.width / 2 + Math.sin(node.x) * rx * hop,
+				y: area.height / 2 - Math.cos(node.x) * ry * hop
+			};
+		}
+		return points;
+	}
+	/** Force-directed placement (Fruchterman and Reingold, 1991, by d3-force), started from `seed` so it repeats exactly and untangles less. */
+	static force(seed, links, area) {
+		const { width, height, cell } = area;
+		const movers = seed.map((point, index) => ({
+			index,
+			x: point.x - width / 2,
+			y: point.y - height / 2
+		}));
+		const reach = Math.max(cell.width, cell.height), span = Math.sqrt(width * height / Math.max(1, seed.length));
+		const simulation = forceSimulation(movers).stop().force("link", forceLink(links.map(([source, target]) => ({
+			source,
+			target
+		}))).distance(Math.max(reach, span * .9)).strength(.4)).force("charge", forceManyBody().strength(-span * 6)).force("collide", forceCollide(reach * .62)).force("x", forceX(0).strength(.05 * height / Math.max(width, 1))).force("y", forceY(0).strength(.05 * width / Math.max(height, 1)));
+		for (let i = 0; i < 300; i++) {
+			simulation.tick();
+			for (const mover of movers) {
+				mover.x = Math.max(cell.width / 2 - width / 2, Math.min(width / 2 - cell.width / 2, mover.x));
+				mover.y = Math.max(cell.height / 2 - height / 2, Math.min(height / 2 - cell.height / 2, mover.y));
+			}
+		}
+		return movers.map((mover) => ({
+			x: mover.x + width / 2,
+			y: mover.y + height / 2
+		}));
+	}
+};
+export { TopologyLayout };

package/dist/charts/diagrams/architectureEnums.js

@@ -0,0 +1,50 @@
+// src/charts/diagrams/architectureEnums.ts
+/** C4 element types, plus the plain grouping box. `Database` is a container drawn as a cylinder. */
+var ArchitectureKind = /* @__PURE__ */ function(ArchitectureKind) {
+	ArchitectureKind["Person"] = "person";
+	ArchitectureKind["System"] = "system";
+	ArchitectureKind["Container"] = "container";
+	ArchitectureKind["Database"] = "database";
+	ArchitectureKind["Component"] = "component";
+	ArchitectureKind["Boundary"] = "boundary";
+	return ArchitectureKind;
+}({});
+/** The C4 zoom level: each one opens the element type above it into a boundary. */
+var ArchitectureLevel = /* @__PURE__ */ function(ArchitectureLevel) {
+	ArchitectureLevel["Context"] = "context";
+	ArchitectureLevel["Containers"] = "containers";
+	ArchitectureLevel["Components"] = "components";
+	return ArchitectureLevel;
+}({});
+var ArchitectureDirection = /* @__PURE__ */ function(ArchitectureDirection) {
+	ArchitectureDirection["TopDown"] = "top-down";
+	ArchitectureDirection["LeftRight"] = "left-right";
+	return ArchitectureDirection;
+}({});
+/** `Direct` draws straight where the way is clear and goes around boxes where it is not. */
+var ArchitectureRouting = /* @__PURE__ */ function(ArchitectureRouting) {
+	ArchitectureRouting["Orthogonal"] = "orthogonal";
+	ArchitectureRouting["Direct"] = "direct";
+	return ArchitectureRouting;
+}({});
+/** `Full` adds each element's description, which is what makes its box taller. */
+var ArchitectureDetail = /* @__PURE__ */ function(ArchitectureDetail) {
+	ArchitectureDetail["Full"] = "full";
+	ArchitectureDetail["Names"] = "names";
+	return ArchitectureDetail;
+}({});
+var NetworkDeviceKind = /* @__PURE__ */ function(NetworkDeviceKind) {
+	NetworkDeviceKind["Cloud"] = "cloud";
+	NetworkDeviceKind["Router"] = "router";
+	NetworkDeviceKind["Switch"] = "switch";
+	NetworkDeviceKind["Server"] = "server";
+	NetworkDeviceKind["Database"] = "database";
+	return NetworkDeviceKind;
+}({});
+var TopologyArrangement = /* @__PURE__ */ function(TopologyArrangement) {
+	TopologyArrangement["Tiered"] = "tiered";
+	TopologyArrangement["Radial"] = "radial";
+	TopologyArrangement["Force"] = "force";
+	return TopologyArrangement;
+}({});
+export { ArchitectureDetail, ArchitectureDirection, ArchitectureKind, ArchitectureLevel, ArchitectureRouting, NetworkDeviceKind, TopologyArrangement };

package/dist/charts/diagrams/index.js

@@ -0,0 +1,26 @@
+import { ArchitectureDetail, ArchitectureDirection, ArchitectureKind, ArchitectureLevel, ArchitectureRouting, NetworkDeviceKind, TopologyArrangement } from "./architectureEnums.js";
+import { ArchitectureModel } from "./ArchitectureModel.js";
+import { DiagramText } from "./DiagramText.js";
+import { ArchitectureFlow, ArchitectureRouter } from "./ArchitectureRouter.js";
+import { ArchitectureDiagram } from "./ArchitectureDiagram.js";
+import { LogicGateKind, LogicLayering, LogicState, LogicStateLabels, LogicSymbolStyle } from "./logicEnums.js";
+import { LogicCircuit } from "./LogicCircuit.js";
+import { LogicGateSymbol } from "./LogicGateSymbol.js";
+import { LogicCircuitLayout } from "./LogicCircuitLayout.js";
+import { LogicCircuitSamples } from "./LogicCircuitSamples.js";
+import { LogicGateDiagram } from "./LogicGateDiagram.js";
+import { TopologyLayout } from "./TopologyLayout.js";
+import { NetworkTopologyDiagram } from "./NetworkTopologyDiagram.js";
+import { ErCardinality, ErSchema } from "./ErSchema.js";
+import { EntityRelationshipDiagram, ErDetail } from "./EntityRelationshipDiagram.js";
+import { SequenceFragmentKind, SequenceMessageKind, SequenceNoteSide, SequenceNumbering, SequenceParticipantKind, SequenceSpacing } from "./sequenceEnums.js";
+import { SequenceDiagram } from "./SequenceDiagram.js";
+// src/charts/diagrams/index.ts
+var diagramsCatalog = [
+	LogicGateDiagram,
+	EntityRelationshipDiagram,
+	ArchitectureDiagram,
+	NetworkTopologyDiagram,
+	SequenceDiagram
+];
+export { ArchitectureDetail, ArchitectureDiagram, ArchitectureDirection, ArchitectureFlow, ArchitectureKind, ArchitectureLevel, ArchitectureModel, ArchitectureRouter, ArchitectureRouting, DiagramText, EntityRelationshipDiagram, ErCardinality, ErDetail, ErSchema, LogicCircuit, LogicCircuitLayout, LogicCircuitSamples, LogicGateDiagram, LogicGateKind, LogicGateSymbol, LogicLayering, LogicState, LogicStateLabels, LogicSymbolStyle, NetworkDeviceKind, NetworkTopologyDiagram, SequenceDiagram, SequenceFragmentKind, SequenceMessageKind, SequenceNoteSide, SequenceNumbering, SequenceParticipantKind, SequenceSpacing, TopologyArrangement, TopologyLayout, diagramsCatalog };

package/dist/charts/diagrams/logicEnums.js

@@ -0,0 +1,42 @@
+// src/charts/diagrams/logicEnums.ts
+/** Primitive of a logic circuit. `Unknown` marks a row whose type was not recognised. */
+var LogicGateKind = /* @__PURE__ */ function(LogicGateKind) {
+	LogicGateKind["Input"] = "input";
+	LogicGateKind["Output"] = "output";
+	LogicGateKind["And"] = "and";
+	LogicGateKind["Or"] = "or";
+	LogicGateKind["Not"] = "not";
+	LogicGateKind["Nand"] = "nand";
+	LogicGateKind["Nor"] = "nor";
+	LogicGateKind["Xor"] = "xor";
+	LogicGateKind["Xnor"] = "xnor";
+	LogicGateKind["Buffer"] = "buffer";
+	LogicGateKind["Unknown"] = "unknown";
+	return LogicGateKind;
+}({});
+/** Ternary signal value: `Unknown` is X, an undriven or unresolved net. */
+var LogicState = /* @__PURE__ */ function(LogicState) {
+	LogicState["False"] = "0";
+	LogicState["True"] = "1";
+	LogicState["Unknown"] = "X";
+	return LogicState;
+}({});
+/** ANSI/IEEE 91 distinctive shapes, or IEC 60617 rectangles with a function qualifier. */
+var LogicSymbolStyle = /* @__PURE__ */ function(LogicSymbolStyle) {
+	LogicSymbolStyle["Ansi"] = "ansi";
+	LogicSymbolStyle["Iec"] = "iec";
+	return LogicSymbolStyle;
+}({});
+/** Which end gates are pushed to when they have slack: as soon as inputs allow, or as late as outputs allow. */
+var LogicLayering = /* @__PURE__ */ function(LogicLayering) {
+	LogicLayering["Inputs"] = "early";
+	LogicLayering["Outputs"] = "late";
+	return LogicLayering;
+}({});
+/** Where the state text goes: on every net, or only on the circuit's terminals. */
+var LogicStateLabels = /* @__PURE__ */ function(LogicStateLabels) {
+	LogicStateLabels["Nets"] = "nets";
+	LogicStateLabels["Terminals"] = "terminals";
+	return LogicStateLabels;
+}({});
+export { LogicGateKind, LogicLayering, LogicState, LogicStateLabels, LogicSymbolStyle };

package/dist/charts/diagrams/sequenceEnums.js

@@ -0,0 +1,40 @@
+// src/charts/diagrams/sequenceEnums.ts
+/** UML message sorts. `Self` is a call a lifeline makes on itself. */
+var SequenceMessageKind = /* @__PURE__ */ function(SequenceMessageKind) {
+	SequenceMessageKind["Sync"] = "sync";
+	SequenceMessageKind["Async"] = "async";
+	SequenceMessageKind["Return"] = "return";
+	SequenceMessageKind["Self"] = "self";
+	return SequenceMessageKind;
+}({});
+var SequenceFragmentKind = /* @__PURE__ */ function(SequenceFragmentKind) {
+	SequenceFragmentKind["Alt"] = "alt";
+	SequenceFragmentKind["Opt"] = "opt";
+	SequenceFragmentKind["Loop"] = "loop";
+	return SequenceFragmentKind;
+}({});
+var SequenceParticipantKind = /* @__PURE__ */ function(SequenceParticipantKind) {
+	SequenceParticipantKind["Object"] = "object";
+	SequenceParticipantKind["Actor"] = "actor";
+	return SequenceParticipantKind;
+}({});
+var SequenceNoteSide = /* @__PURE__ */ function(SequenceNoteSide) {
+	SequenceNoteSide["Over"] = "over";
+	SequenceNoteSide["Left"] = "left";
+	SequenceNoteSide["Right"] = "right";
+	return SequenceNoteSide;
+}({});
+/** `Nested` numbers calls by their depth (1, 1.1, 1.2), as UML's decimal message numbers do. */
+var SequenceNumbering = /* @__PURE__ */ function(SequenceNumbering) {
+	SequenceNumbering["None"] = "none";
+	SequenceNumbering["Flat"] = "flat";
+	SequenceNumbering["Nested"] = "nested";
+	return SequenceNumbering;
+}({});
+/** `Fitted` widens each gap only as far as its labels need; `Even` makes every gap the widest one. */
+var SequenceSpacing = /* @__PURE__ */ function(SequenceSpacing) {
+	SequenceSpacing["Fitted"] = "fitted";
+	SequenceSpacing["Even"] = "even";
+	return SequenceSpacing;
+}({});
+export { SequenceFragmentKind, SequenceMessageKind, SequenceNoteSide, SequenceNumbering, SequenceParticipantKind, SequenceSpacing };

package/dist/charts/distribution/HistogramChart.js

@@ -6,6 +6,18 @@ import { DistributionStats } from "./DistributionStats.js";
 import { BinRule, DistributionFit, DistributionLayout, FrequencyScale, HistogramShape, KernelKind, KernelSmoothing } from "./enums.js";
 import { max } from "d3";
 // src/charts/distribution/HistogramChart.ts
+var ROUND_STEPS = [
+	1,
+	1.5,
+	2,
+	2.5,
+	3,
+	4,
+	5,
+	6,
+	8,
+	10
+];
 /** Shows the shape of a distribution by counting values into bins; the first chart to reach for with one numeric column. */
 var HistogramChart = class extends BinnedChart {
 	static meta = {
@@ -61,9 +73,18 @@ var HistogramChart = class extends BinnedChart {
 			...super.defaults(),
 			layout: DistributionLayout.Pooled,
 			shape: HistogramShape.Bars,
-			fit: DistributionFit.None
+			fit: DistributionFit.None,
+			roundBins: false
 		};
 	}
+	edges(samples) {
+		const edges = super.edges(samples);
+		if (!this.options.roundBins || edges.length < 2) return edges;
+		const raw = edges[1] - edges[0], power = 10 ** Math.floor(Math.log10(raw));
+		const step = ROUND_STEPS.reduce((best, candidate) => Math.abs(candidate * power - raw) < Math.abs(best - raw) ? candidate * power : best, power);
+		const first = Math.floor(edges[0] / step), count = Math.ceil(edges[edges.length - 1] / step) - first;
+		return Array.from({ length: Math.max(1, count) + 1 }, (_, i) => (first + i) * step);
+	}
 	get pooled() {
 		return this.options.layout === DistributionLayout.Pooled;
 	}
@@ -91,9 +112,10 @@ var HistogramChart = class extends BinnedChart {
 	fitLine(samples) {
 		const { fit, frequency } = this.options;
 		const sample = samples[0];
-		if (!sample || fit === DistributionFit.None) return [];
+		if (!sample || fit === DistributionFit.None || !this.pooled || frequency === FrequencyScale.Cumulative) return [];
 		const edges = this.edges(samples), s = sample.summary;
-		const unit = frequency === FrequencyScale.Density ? 1 : s.n * (edges[1] - edges[0]);
+		const width = edges[1] - edges[0];
+		const unit = frequency === FrequencyScale.Density ? 1 : frequency === FrequencyScale.Percent ? width : s.n * width;
 		const curve = fit === DistributionFit.Kde ? DistributionStats.density(sample.values, KernelKind.Gaussian, KernelSmoothing.Balanced) : [];
 		const steps = 80;
 		return Array.from({ length: 81 }, (_, i) => {

package/dist/charts/distribution/index.js

@@ -16,7 +16,6 @@ import { LetterValuePlot } from "./LetterValuePlot.js";
 import { ParetoChart } from "./ParetoChart.js";
 import { QuantileDotplot } from "./QuantileDotplot.js";
 import { RaincloudChart } from "./RaincloudChart.js";
-import { RidgeSlabs3DChart } from "./RidgeSlabs3DChart.js";
 import { RidgelineChart } from "./RidgelineChart.js";
 import { SinaPlot } from "./SinaPlot.js";
 import { StemLeaf } from "./StemLeaf.js";
@@ -47,7 +46,6 @@ var distributionCatalog = [
 	BackToBackHistogram,
 	BeanPlot,
 	DensityStrip,
-	RidgeSlabs3DChart,
 	Violin3DChart
 ];
-export { BackToBackHistogram, BarcodeAlign, BarcodeLength, BarcodeOverlay, BarcodePlot, BeanLine, BeanPlot, BeeswarmChart, BinRule, BoxPlot, BoxStyle, BoxWidth, BoxenChart, BoxenScale, CdfBand, CdfForm, CdfLine, CumulativeDistribution, DensityChart, DensityScaling, DensitySide, DensityStrip, DistributionFit, DistributionLayout, DotBinning, DotLayout, DotStackDirection, Dotplot, FrequencyPolygon, FrequencyScale, GroupOrder, HalfEyePlot, HistogramChart, HistogramShape, IntervalSet, KernelKind, KernelSmoothing, LeafMark, LetterDepth, LetterForm, LetterValuePlot, ParetoChart, ParetoCutoff, ParetoLine, ParetoTail, PointEstimate, QuantileDotplot, RainStyle, RaincloudChart, Ridge3DForm, RidgeMarker, RidgeMode, RidgeScaling, RidgeSlabs3DChart, RidgelineChart, SinaOverlay, SinaPlot, SinaSpread, SlabForm, StemLayout, StemLeaf, StripJitter, StripMark, StripPlot, StripSummary, StripeForm, StripeMarker, StripeProfile, SwarmLanes, SwarmSide, Violin3DChart, Violin3DForm, ViolinChart, ViolinInner, WhiskerRule, distributionCatalog };
+export { BackToBackHistogram, BarcodeAlign, BarcodeLength, BarcodeOverlay, BarcodePlot, BeanLine, BeanPlot, BeeswarmChart, BinRule, BoxPlot, BoxStyle, BoxWidth, BoxenChart, BoxenScale, CdfBand, CdfForm, CdfLine, CumulativeDistribution, DensityChart, DensityScaling, DensitySide, DensityStrip, DistributionFit, DistributionLayout, DotBinning, DotLayout, DotStackDirection, Dotplot, FrequencyPolygon, FrequencyScale, GroupOrder, HalfEyePlot, HistogramChart, HistogramShape, IntervalSet, KernelKind, KernelSmoothing, LeafMark, LetterDepth, LetterForm, LetterValuePlot, ParetoChart, ParetoCutoff, ParetoLine, ParetoTail, PointEstimate, QuantileDotplot, RainStyle, RaincloudChart, Ridge3DForm, RidgeMarker, RidgeMode, RidgeScaling, RidgelineChart, SinaOverlay, SinaPlot, SinaSpread, SlabForm, StemLayout, StemLeaf, StripJitter, StripMark, StripPlot, StripSummary, StripeForm, StripeMarker, StripeProfile, SwarmLanes, SwarmSide, Violin3DChart, Violin3DForm, ViolinChart, ViolinInner, WhiskerRule, distributionCatalog };