@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/data/GeoAtlas.js

@@ -0,0 +1,119 @@
+import states_10m_default from "../vendor/us-atlas/states-10m.json.js";
+import { feature, mesh } from "topojson-client";
+// src/data/GeoAtlas.ts
+/** Bundled geography. World layers are Natural Earth; US layers are Census cartographic boundaries. */
+var GeoLayer = /* @__PURE__ */ function(GeoLayer) {
+	GeoLayer["World110m"] = "world-110m";
+	GeoLayer["World50m"] = "world-50m";
+	GeoLayer["World10m"] = "world-10m";
+	GeoLayer["UsStates"] = "us-states";
+	GeoLayer["UsCounties"] = "us-counties";
+	return GeoLayer;
+}({});
+var OBJECT = {
+	["world-110m"]: "countries",
+	["world-50m"]: "countries",
+	["world-10m"]: "countries",
+	["us-states"]: "states",
+	["us-counties"]: "counties"
+};
+var SOURCES = {
+	["world-110m"]: () => import("../vendor/world-atlas/countries-110m.json.js"),
+	["world-50m"]: () => import("../vendor/world-atlas/countries-50m.json.js"),
+	["world-10m"]: () => import("../vendor/world-atlas/countries-10m.json.js"),
+	["us-states"]: async () => ({ default: states_10m_default }),
+	["us-counties"]: () => import("../vendor/us-atlas/counties-10m.json.js")
+};
+var POSTAL = "AL AK . AZ AR CA . CO CT DE DC FL GA . HI ID IL IN IA KS KY LA ME MD MA MI MN MS MO MT NE NV NH NJ NM NY NC ND OH OK OR PA . RI SC SD TN TX UT VT VA . WA WV WI WY".split(" ");
+var TERRITORIES = {
+	60: "AS",
+	66: "GU",
+	69: "MP",
+	72: "PR",
+	78: "VI"
+};
+var USA = "840";
+/** Loads geography on demand, so an app only downloads the layers it draws. */
+var GeoAtlas = class {
+	static ready = /* @__PURE__ */ new Map();
+	static loading = /* @__PURE__ */ new Map();
+	static counties = /* @__PURE__ */ new Map();
+	/** Two-letter postal code of a state FIPS id, when it has one. */
+	static postal(fips) {
+		const code = POSTAL[+fips - 1];
+		return TERRITORIES[+fips] ?? (code && code !== "." ? code : void 0);
+	}
+	static read(layer, atlas) {
+		const collection = feature(atlas, atlas.objects[OBJECT[layer]]);
+		const features = collection.features.map((item) => {
+			const fips = String(item.id ?? "");
+			if (!(layer === "us-states" || layer === "us-counties")) return {
+				...item,
+				properties: {
+					...item.properties,
+					iso: fips
+				}
+			};
+			const state = layer === "us-states" ? fips : fips.slice(0, 2);
+			return {
+				...item,
+				properties: {
+					...item.properties,
+					fips,
+					code: this.postal(state),
+					state
+				}
+			};
+		});
+		return {
+			...collection,
+			features
+		};
+	}
+	/** The layer if it is already in memory. */
+	static peek(layer) {
+		if (layer === "us-states" && !this.ready.has(layer)) this.ready.set(layer, this.read(layer, states_10m_default));
+		return this.ready.get(layer);
+	}
+	static load(layer) {
+		const known = this.peek(layer);
+		if (known) return Promise.resolve(known);
+		let pending = this.loading.get(layer);
+		if (!pending) {
+			pending = SOURCES[layer]().then((module) => {
+				const collection = this.read(layer, module.default);
+				this.ready.set(layer, collection);
+				return collection;
+			}).finally(() => this.loading.delete(layer));
+			this.loading.set(layer, pending);
+		}
+		return pending;
+	}
+	/** State outlines, always in memory because the US maps preview with them. */
+	static get states() {
+		return this.peek("us-states");
+	}
+	/** Lines between states, without doubled shared edges. */
+	static get stateBorders() {
+		return mesh(states_10m_default, states_10m_default.objects.states, (a, b) => a !== b);
+	}
+	/** The counties of one state, by its two-digit FIPS id. */
+	static async countiesOf(state) {
+		const known = this.counties.get(state);
+		if (known) return known;
+		const { features } = await this.load("us-counties");
+		const picked = {
+			type: "FeatureCollection",
+			features: features.filter((item) => String(item.id).startsWith(state))
+		};
+		this.counties.set(state, picked);
+		return picked;
+	}
+	/** The next level down in the bundled data: country to states to counties. Null at the bottom. */
+	static async children(region) {
+		const id = String(region.id ?? "");
+		if (id === USA) return this.load("us-states");
+		return id.length === 2 && region.properties?.code ? this.countiesOf(id) : null;
+	}
+};
+export { GeoAtlas, GeoLayer };

package/dist/data/SampleData.js

@@ -0,0 +1,345 @@
+import countries_110m_default from "../vendor/world-atlas/countries-110m.json.js";
+import { randomLcg, randomNormal, randomUniform } from "d3";
+import { feature } from "topojson-client";
+// src/data/SampleData.ts
+var NAMES = [
+	"North",
+	"South",
+	"East",
+	"West",
+	"Central",
+	"Coastal",
+	"Upland",
+	"Metro",
+	"Harbor",
+	"Valley",
+	"Ridge",
+	"Delta"
+];
+var SERIES = [
+	"Alpha",
+	"Bravo",
+	"Charlie",
+	"Delta",
+	"Echo",
+	"Foxtrot",
+	"Golf",
+	"Hotel"
+];
+/** Deterministic demo datasets: same seed, same data. All gallery and test data comes from here. */
+var SampleData = class {
+	static rng(seed) {
+		const source = randomLcg(seed * .6180339887 % 1);
+		return {
+			u: randomUniform.source(source)(0, 1),
+			n: randomNormal.source(source)(0, 1)
+		};
+	}
+	/** `{ category, series, value }`, long form. */
+	static categories(seed = 1, categories = 7, series = 3) {
+		const { u } = this.rng(seed);
+		return NAMES.slice(0, categories).flatMap((category) => SERIES.slice(0, series).map((name) => ({
+			category,
+			series: name,
+			value: Math.round(20 + u() * 80)
+		})));
+	}
+	/** `{ date, series, value }`, a daily random walk per series. */
+	static timeSeries(seed = 1, points = 60, series = 3) {
+		const { n } = this.rng(seed);
+		return SERIES.slice(0, series).flatMap((name, s) => {
+			let value = 50 + s * 18;
+			return Array.from({ length: points }, (_, i) => {
+				value = Math.max(2, value + n() * 3 + .15);
+				return {
+					date: new Date(Date.UTC(2026, 0, 1 + i)),
+					series: name,
+					value: +value.toFixed(2)
+				};
+			});
+		});
+	}
+	/** `{ x, y, size, group }`, clustered with correlation. */
+	static points(seed = 1, count = 120, groups = 3) {
+		const { u, n } = this.rng(seed);
+		return Array.from({ length: count }, (_, i) => {
+			const g = i % groups, x = 20 + g * 22 + n() * 8;
+			return {
+				x: +x.toFixed(2),
+				y: +(x * .8 + 10 + n() * 9).toFixed(2),
+				size: +(3 + u() * 30).toFixed(1),
+				group: SERIES[g]
+			};
+		});
+	}
+	/** `{ group, value }`, normally distributed per group with shifted means. */
+	static distribution(seed = 1, perGroup = 200, groups = 4) {
+		const { n } = this.rng(seed);
+		return SERIES.slice(0, groups).flatMap((group, g) => Array.from({ length: perGroup }, () => ({
+			group,
+			value: +(40 + g * 9 + n() * (8 + g * 2)).toFixed(2)
+		})));
+	}
+	/** `{ date, open, high, low, close, volume }`. */
+	static ohlc(seed = 1, points = 60) {
+		const { u, n } = this.rng(seed);
+		let close = 100;
+		return Array.from({ length: points }, (_, i) => {
+			const open = close;
+			close = Math.max(5, open + n() * 2.4);
+			return {
+				date: new Date(Date.UTC(2026, 0, 1 + i)),
+				open: +open.toFixed(2),
+				close: +close.toFixed(2),
+				high: +(Math.max(open, close) + u() * 1.6).toFixed(2),
+				low: +(Math.min(open, close) - u() * 1.6).toFixed(2),
+				volume: Math.round(1e3 + u() * 9e3)
+			};
+		});
+	}
+	static tree(seed = 1, depth = 3, breadth = 4) {
+		const { u } = this.rng(seed);
+		const grow = (name, level) => level === depth ? {
+			name,
+			value: Math.round(5 + u() * 95)
+		} : {
+			name,
+			children: Array.from({ length: 2 + Math.floor(u() * (breadth - 1)) }, (_, i) => grow(`${name.slice(0, 1)}${level}.${i + 1}`, level + 1))
+		};
+		return {
+			...grow("Root", 0),
+			name: "Root"
+		};
+	}
+	/** Clustered graph: `{ nodes: [{ id, group, value }], links: [{ source, target, value }] }`. */
+	static graph(seed = 1, count = 40, groups = 4) {
+		const { u } = this.rng(seed);
+		const nodes = Array.from({ length: count }, (_, i) => ({
+			id: `n${i}`,
+			group: SERIES[i % groups],
+			value: Math.round(1 + u() * 9)
+		}));
+		return {
+			nodes,
+			links: nodes.slice(1).flatMap((node, i) => {
+				const peers = nodes.slice(0, i + 1).filter((other) => other.group === node.group);
+				return [{
+					source: (peers.length && u() < .85 ? peers[Math.floor(u() * peers.length)] : nodes[Math.floor(u() * (i + 1))]).id,
+					target: node.id,
+					value: Math.round(1 + u() * 9)
+				}];
+			})
+		};
+	}
+	/** Layered acyclic flow for sankey-like charts. Node ids are `L<layer>-<i>`. */
+	static flow(seed = 1, layers = 4, width = 4) {
+		const { u } = this.rng(seed);
+		return {
+			nodes: Array.from({ length: layers }, (_, l) => Array.from({ length: width }, (_, i) => ({
+				id: `L${l}-${i}`,
+				group: `Layer ${l + 1}`
+			}))).flat(),
+			links: Array.from({ length: layers - 1 }, (_, l) => Array.from({ length: width }, (_, a) => [a, (a + 1) % width].map((b) => ({
+				source: `L${l}-${a}`,
+				target: `L${l + 1}-${b}`,
+				value: Math.round(5 + u() * 40)
+			})))).flat(2)
+		};
+	}
+	static matrix(seed = 1, rows = 10, columns = 12) {
+		const { u } = this.rng(seed);
+		return {
+			rows: Array.from({ length: rows }, (_, i) => `R${i + 1}`),
+			columns: Array.from({ length: columns }, (_, i) => `C${i + 1}`),
+			values: Array.from({ length: rows }, (_, r) => Array.from({ length: columns }, (_, c) => +(Math.sin(r / 3) * Math.cos(c / 4) + u() * .3).toFixed(3)))
+		};
+	}
+	/** Rolling surface sampled on an `n × n` grid. */
+	static surface(seed = 1, n = 40) {
+		const axis = Array.from({ length: n }, (_, i) => i / (n - 1) * 2 - 1);
+		return {
+			x: axis,
+			y: axis,
+			z: axis.map((y) => axis.map((x) => Math.sin(x * 3 + seed) * Math.cos(y * 3) * Math.exp(-(x * x + y * y) / 1.8)))
+		};
+	}
+	/** Gaussian blobs in an `n³` volume. */
+	static volume(seed = 1, n = 24) {
+		const blobs = [
+			[
+				.35,
+				.4,
+				.5
+			],
+			[
+				.65,
+				.6,
+				.4
+			],
+			[
+				.5,
+				.3 + seed % 3 * .1,
+				.7
+			]
+		];
+		const values = new Float32Array(n ** 3);
+		for (let z = 0; z < n; z++) for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) values[x + y * n + z * n * n] = blobs.reduce((sum, [a, b, c]) => sum + Math.exp(-((x / n - a) ** 2 + (y / n - b) ** 2 + (z / n - c) ** 2) * 30), 0);
+		return {
+			size: [
+				n,
+				n,
+				n
+			],
+			values
+		};
+	}
+	/** Lower-48-free world countries as GeoJSON features; `properties.value` is seeded. */
+	static world(seed = 1) {
+		const { u } = this.rng(seed);
+		const geo = feature(countries_110m_default, countries_110m_default.objects.countries);
+		return {
+			...geo,
+			features: geo.features.map((f) => ({
+				...f,
+				properties: {
+					...f.properties,
+					value: +(u() * 100).toFixed(1)
+				}
+			}))
+		};
+	}
+	/** `{ name, lon, lat, value }`, world cities. */
+	static cities(seed = 1) {
+		const { u } = this.rng(seed);
+		return [
+			[
+				"New York",
+				-74,
+				40.7
+			],
+			[
+				"London",
+				-.1,
+				51.5
+			],
+			[
+				"Tokyo",
+				139.7,
+				35.7
+			],
+			[
+				"Sydney",
+				151.2,
+				-33.9
+			],
+			[
+				"São Paulo",
+				-46.6,
+				-23.5
+			],
+			[
+				"Cairo",
+				31.2,
+				30
+			],
+			[
+				"Mumbai",
+				72.9,
+				19.1
+			],
+			[
+				"Lagos",
+				3.4,
+				6.5
+			],
+			[
+				"Moscow",
+				37.6,
+				55.8
+			],
+			[
+				"Mexico City",
+				-99.1,
+				19.4
+			],
+			[
+				"Beijing",
+				116.4,
+				39.9
+			],
+			[
+				"Paris",
+				2.35,
+				48.9
+			],
+			[
+				"Toronto",
+				-79.4,
+				43.7
+			],
+			[
+				"Singapore",
+				103.8,
+				1.35
+			],
+			[
+				"Cape Town",
+				18.4,
+				-33.9
+			],
+			[
+				"Lima",
+				-77,
+				-12
+			],
+			[
+				"Istanbul",
+				29,
+				41
+			],
+			[
+				"Seoul",
+				127,
+				37.6
+			],
+			[
+				"Jakarta",
+				106.8,
+				-6.2
+			],
+			[
+				"Nairobi",
+				36.8,
+				-1.3
+			]
+		].map(([name, lon, lat]) => ({
+			name,
+			lon,
+			lat,
+			value: Math.round(10 + u() * 90)
+		}));
+	}
+	/** `{ text, value }`, weighted words. */
+	static words(seed = 1) {
+		const { u } = this.rng(seed);
+		return "data chart graph scale axis legend color shape signal trend pattern insight story metric model series value range sample cluster layer flow network map".split(" ").map((text) => ({
+			text,
+			value: Math.round(8 + u() ** 2 * 60)
+		}));
+	}
+	/** `{ task, start, end, group, progress }`, overlapping project tasks. */
+	static tasks(seed = 1, count = 14) {
+		const { u } = this.rng(seed);
+		return Array.from({ length: count }, (_, i) => {
+			const start = i * 3 + Math.floor(u() * 6), length = 4 + Math.floor(u() * 14);
+			return {
+				task: `Task ${i + 1}`,
+				start: new Date(Date.UTC(2026, 0, 1 + start)),
+				end: new Date(Date.UTC(2026, 0, 1 + start + length)),
+				group: SERIES[i % 4],
+				progress: +u().toFixed(2)
+			};
+		});
+	}
+};
+export { SampleData };