@mstone6969/graph 0.1.0 → 0.2.0

package/dist/charts/diagrams/ErSamples.js

@@ -0,0 +1,205 @@
+import { ErCardinality } from "./ErSchema.js";
+// src/charts/diagrams/ErSamples.ts
+var SHOP = [
+	[
+		"customers",
+		"id",
+		"uuid",
+		"PK"
+	],
+	[
+		"customers",
+		"email",
+		"text",
+		"UK"
+	],
+	[
+		"customers",
+		"name",
+		"text",
+		""
+	],
+	[
+		"customers",
+		"referred_by",
+		"uuid",
+		"",
+		"customers.id",
+		"YES",
+		"refers"
+	],
+	[
+		"profiles",
+		"customer_id",
+		"uuid",
+		"PK",
+		"customers.id",
+		"NO",
+		"has"
+	],
+	[
+		"profiles",
+		"avatar_url",
+		"text",
+		"",
+		void 0,
+		"YES"
+	],
+	[
+		"orders",
+		"id",
+		"uuid",
+		"PK"
+	],
+	[
+		"orders",
+		"customer_id",
+		"uuid",
+		"",
+		"customers.id",
+		"NO",
+		"places"
+	],
+	[
+		"orders",
+		"placed_at",
+		"timestamptz",
+		""
+	],
+	[
+		"orders",
+		"status",
+		"text",
+		""
+	],
+	[
+		"order_lines",
+		"order_id",
+		"uuid",
+		"PK",
+		"orders.id",
+		"NO",
+		"contains",
+		ErCardinality.OneOrMany
+	],
+	[
+		"order_lines",
+		"line_no",
+		"int",
+		"PK"
+	],
+	[
+		"order_lines",
+		"product_id",
+		"uuid",
+		"",
+		"products.id",
+		"NO",
+		"sold as"
+	],
+	[
+		"order_lines",
+		"quantity",
+		"int",
+		""
+	],
+	[
+		"products",
+		"id",
+		"uuid",
+		"PK"
+	],
+	[
+		"products",
+		"sku",
+		"text",
+		"UK"
+	],
+	[
+		"products",
+		"category_id",
+		"uuid",
+		"",
+		"categories.id",
+		"YES",
+		"groups"
+	],
+	[
+		"products",
+		"price",
+		"numeric",
+		""
+	],
+	[
+		"categories",
+		"id",
+		"uuid",
+		"PK"
+	],
+	[
+		"categories",
+		"name",
+		"text",
+		""
+	],
+	[
+		"payments",
+		"id",
+		"uuid",
+		"PK"
+	],
+	[
+		"payments",
+		"order_id",
+		"uuid",
+		"UK",
+		"orders.id",
+		"NO",
+		"settled by"
+	],
+	[
+		"payments",
+		"amount",
+		"numeric",
+		""
+	]
+];
+var COUPONS = [
+	[
+		"coupons",
+		"code",
+		"text",
+		"PK"
+	],
+	[
+		"coupons",
+		"percent_off",
+		"int",
+		""
+	],
+	[
+		"orders",
+		"coupon_code",
+		"text",
+		"",
+		"coupons.code",
+		"YES",
+		"discounts"
+	]
+];
+/** A synthetic online shop schema, invented for the sample: it describes no real database. Odd seeds add coupons. */
+var ErSamples = class {
+	static shop(seed) {
+		return (seed % 2 ? [...SHOP, ...COUPONS] : SHOP).map(([table, column, type, key, references, nullable, relation, childEnd]) => ({
+			table,
+			column,
+			type,
+			key,
+			references,
+			nullable: nullable ?? "NO",
+			relation,
+			childEnd
+		}));
+	}
+};
+export { ErSamples };

package/dist/charts/diagrams/ErSchema.js

@@ -0,0 +1,122 @@
+// src/charts/diagrams/ErSchema.ts
+/** Crow's foot end marks: the outer symbol is the minimum, the one against the entity the maximum. */
+var ErCardinality = /* @__PURE__ */ function(ErCardinality) {
+	ErCardinality["ExactlyOne"] = "exactly-one";
+	ErCardinality["ZeroOrOne"] = "zero-or-one";
+	ErCardinality["OneOrMany"] = "one-or-many";
+	ErCardinality["ZeroOrMany"] = "zero-or-many";
+	return ErCardinality;
+}({});
+var PRIMARY = /* @__PURE__ */ new Set([
+	"PK",
+	"PRI",
+	"PRIMARY"
+]);
+var UNIQUE = /* @__PURE__ */ new Set([
+	"UK",
+	"UQ",
+	"UNI",
+	"UNIQUE"
+]);
+var NULLABLE = /* @__PURE__ */ new Set([
+	"YES",
+	"Y",
+	"TRUE",
+	"1",
+	"NULL",
+	"NULLABLE"
+]);
+var ENDS = new Set(Object.values(ErCardinality));
+var text = (cell) => cell === null || cell === void 0 ? "" : String(cell).trim();
+var end = (cell, fallback) => ENDS.has(text(cell)) ? text(cell) : fallback;
+var bare = (name) => name.replace(/["`\[\]]/g, "").trim().toLowerCase();
+var leaf = (name) => name.slice(name.lastIndexOf(".") + 1);
+/** The table part of a reference: `orders.id`, `public.orders.id`, `orders(id)`, or a bare `orders`. */
+function targetTable(reference) {
+	const call = reference.indexOf("(");
+	if (call >= 0) return reference.slice(0, call).trim();
+	const dot = reference.lastIndexOf(".");
+	return dot < 0 ? reference : reference.slice(0, dot);
+}
+/**
+* Finds the table a reference means, the way SQL resolves it: ignoring quotes and case, and with a
+* schema prefix on either side. `information_schema` often gives `table_name` unqualified while the
+* reference is qualified. A short name that fits two tables resolves to neither.
+*/
+function resolver(tables) {
+	const full = new Map(tables.map((id) => [bare(id), id]));
+	const short = /* @__PURE__ */ new Map();
+	for (const id of tables) short.set(leaf(bare(id)), short.has(leaf(bare(id))) ? null : id);
+	return (reference) => {
+		const whole = bare(reference), table = bare(targetTable(reference));
+		return full.get(whole) ?? full.get(table) ?? short.get(leaf(table)) ?? void 0;
+	};
+}
+/** Turns one-row-per-column schema rows into tables and foreign key relationships. */
+var ErSchema = class {
+	static read(rows, fields) {
+		const tables = /* @__PURE__ */ new Map();
+		const groups = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			if (row === null || typeof row !== "object") continue;
+			const id = text(row[fields.table]), name = text(row[fields.column]);
+			if (!id) continue;
+			if (!tables.has(id)) tables.set(id, {
+				id,
+				columns: []
+			});
+			const table = tables.get(id);
+			if (!name || table.columns.some((column) => column.name === name)) continue;
+			const tokens = text(row[fields.key]).toUpperCase().split(/[\s,;/+]+/);
+			const references = text(row[fields.references]);
+			const column = {
+				name,
+				references,
+				type: text(row[fields.dataType]),
+				foreign: !!references,
+				primary: tokens.some((token) => PRIMARY.has(token)),
+				unique: tokens.some((token) => UNIQUE.has(token)),
+				nullable: NULLABLE.has(text(row[fields.nullable]).toUpperCase())
+			};
+			table.columns.push(column);
+			if (!references) continue;
+			const parent = targetTable(references), constraint = text(row[fields.constraint]);
+			const key = `${id}\0${constraint || name}\0${parent}`;
+			const group = groups.get(key) ?? {
+				child: id,
+				parent,
+				constraint,
+				rows: [],
+				columns: []
+			};
+			group.rows.push(row);
+			group.columns.push(column);
+			groups.set(key, group);
+		}
+		const resolve = resolver([...tables.keys()]);
+		const relationships = [...groups.entries()].flatMap(([key, group]) => {
+			const parent = resolve(text(group.rows[0][fields.references]));
+			if (parent === void 0) return [];
+			const { child, constraint, columns } = group, first = group.rows[0];
+			const primaries = tables.get(child).columns.filter((column) => column.primary);
+			const single = columns.length === primaries.length && columns.every((column) => column.primary) || columns.length === 1 && columns[0].unique;
+			return [{
+				key,
+				child,
+				parent,
+				constraint,
+				columns: columns.map((column) => column.name),
+				references: columns.map((column) => column.references),
+				label: text(first[fields.relation]),
+				parentEnd: end(first[fields.parentEnd], columns.some((column) => column.nullable) ? "zero-or-one" : "exactly-one"),
+				childEnd: end(first[fields.childEnd], single ? "zero-or-one" : "zero-or-many"),
+				identifying: columns.every((column) => column.primary)
+			}];
+		});
+		return {
+			tables: [...tables.values()],
+			relationships
+		};
+	}
+};
+export { ErCardinality, ErSchema };

package/dist/charts/diagrams/LogicCircuit.js

@@ -0,0 +1,154 @@
+import { LogicGateKind, LogicState } from "./logicEnums.js";
+// src/charts/diagrams/LogicCircuit.ts
+var KINDS = new Set(Object.values(LogicGateKind));
+var ALIASES = {
+	buf: LogicGateKind.Buffer,
+	inv: LogicGateKind.Not,
+	inverter: LogicGateKind.Not
+};
+var TRUE = /* @__PURE__ */ new Set([
+	"1",
+	"true",
+	"t",
+	"high",
+	"h"
+]);
+var FALSE = /* @__PURE__ */ new Set([
+	"0",
+	"false",
+	"f",
+	"low",
+	"l"
+]);
+var SINGLE = /* @__PURE__ */ new Set([
+	LogicGateKind.Not,
+	LogicGateKind.Buffer,
+	LogicGateKind.Output
+]);
+var { True, False, Unknown } = LogicState;
+/**
+* A gate-level netlist evaluated by ternary (Kleene 0/1/X) simulation, after Eichelberger (1965):
+* every net starts at X and gates are re-evaluated to a fixed point. The gate functions are
+* monotone in X, so this always settles: a stable latch resolves when its inputs force it and
+* stays X when they do not, and an oscillator stays X. XOR and XNOR of more than two inputs are
+* odd and even parity, as in Verilog's primitives.
+*/
+var LogicCircuit = class LogicCircuit {
+	static fields = {
+		id: "id",
+		kind: "type",
+		label: "label",
+		value: "value",
+		from: "from",
+		to: "to"
+	};
+	nodes = /* @__PURE__ */ new Map();
+	/** Rows that could not be used, in plain words. */
+	issues = [];
+	constructor(data, fields = {}) {
+		const names = {
+			...LogicCircuit.fields,
+			...fields
+		};
+		const given = this.#readGates(data?.gates ?? [], names);
+		this.#readWires(data?.wires ?? [], names);
+		this.#settle(given);
+	}
+	static parseState(value) {
+		const text = String(value ?? "").trim().toLowerCase();
+		return TRUE.has(text) ? True : FALSE.has(text) ? False : Unknown;
+	}
+	static evaluate(kind, inputs) {
+		switch (kind) {
+			case LogicGateKind.Output:
+			case LogicGateKind.Buffer: return inputs[0] ?? Unknown;
+			case LogicGateKind.Not: return LogicCircuit.#invert(inputs[0] ?? Unknown);
+			case LogicGateKind.And: return LogicCircuit.#and(inputs);
+			case LogicGateKind.Nand: return LogicCircuit.#invert(LogicCircuit.#and(inputs));
+			case LogicGateKind.Or: return LogicCircuit.#or(inputs);
+			case LogicGateKind.Nor: return LogicCircuit.#invert(LogicCircuit.#or(inputs));
+			case LogicGateKind.Xor: return LogicCircuit.#parity(inputs);
+			case LogicGateKind.Xnor: return LogicCircuit.#invert(LogicCircuit.#parity(inputs));
+			default: return Unknown;
+		}
+	}
+	static #invert(state) {
+		return state === Unknown ? Unknown : state === True ? False : True;
+	}
+	static #and(inputs) {
+		if (!inputs.length) return Unknown;
+		return inputs.includes(False) ? False : inputs.includes(Unknown) ? Unknown : True;
+	}
+	static #or(inputs) {
+		if (!inputs.length) return Unknown;
+		return inputs.includes(True) ? True : inputs.includes(Unknown) ? Unknown : False;
+	}
+	static #parity(inputs) {
+		if (!inputs.length || inputs.includes(Unknown)) return Unknown;
+		return inputs.filter((state) => state === True).length % 2 ? True : False;
+	}
+	static #kind(value) {
+		const text = String(value ?? "").trim().toLowerCase();
+		return KINDS.has(text) && text !== LogicGateKind.Unknown ? text : ALIASES[text] ?? null;
+	}
+	#readGates(rows, names) {
+		const given = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const raw = row?.[names.id];
+			if (raw === null || raw === void 0 || raw === "") {
+				this.issues.push("Gate row without an id was skipped");
+				continue;
+			}
+			const id = String(raw);
+			if (this.nodes.has(id)) {
+				this.issues.push(`Duplicate gate ${id} was skipped`);
+				continue;
+			}
+			const kind = LogicCircuit.#kind(row[names.kind]);
+			if (!kind) this.issues.push(`Gate ${id} has unknown type ${String(row[names.kind])}`);
+			this.nodes.set(id, {
+				id,
+				kind: kind ?? LogicGateKind.Unknown,
+				label: String(row[names.label] ?? id),
+				inputs: [],
+				state: Unknown
+			});
+			if (kind === LogicGateKind.Input) given.set(id, LogicCircuit.parseState(row[names.value]));
+		}
+		return given;
+	}
+	#readWires(rows, names) {
+		for (const row of rows) {
+			const from = this.nodes.get(String(row?.[names.from]));
+			const to = this.nodes.get(String(row?.[names.to]));
+			const name = `${String(row?.[names.from])} to ${String(row?.[names.to])}`;
+			if (!from || !to) this.issues.push(`Wire ${name} names a missing gate`);
+			else if (from.kind === LogicGateKind.Output) this.issues.push(`Wire ${name} leaves an output`);
+			else if (to.kind === LogicGateKind.Input) this.issues.push(`Wire ${name} drives an input`);
+			else if (SINGLE.has(to.kind) && to.inputs.length) this.issues.push(`Wire ${name} is a second driver of a one-input pin`);
+			else to.inputs.push(from.id);
+		}
+		for (const node of this.nodes.values()) {
+			const least = node.kind === LogicGateKind.Input ? 0 : SINGLE.has(node.kind) ? 1 : 2;
+			while (node.inputs.length < least) node.inputs.push(null);
+		}
+	}
+	#settle(given) {
+		const nodes = [...this.nodes.values()];
+		for (const node of nodes) node.state = given.get(node.id) ?? Unknown;
+		const logic = nodes.filter((node) => node.kind !== LogicGateKind.Input);
+		let changed = true;
+		while (changed) {
+			changed = false;
+			for (const node of logic) {
+				const inputs = node.inputs.map((id) => id === null ? Unknown : this.nodes.get(id).state);
+				const state = LogicCircuit.evaluate(node.kind, inputs);
+				if (state !== node.state) {
+					node.state = state;
+					changed = true;
+				}
+			}
+		}
+	}
+};
+export { LogicCircuit };