react-graph-grid 0.1.4 → 0.1.6

package/dist/index18.esm.js

@@ -0,0 +1,261 @@
+var GraphClass = class {
+	constructor() {
+		const graph = this;
+		graph.nodesDict = {};
+		graph.linksDict = {};
+		graph.waveCache = {};
+		graph.nodeCount = 0;
+		graph.lastWaveInd = 0;
+		graph.lastWaveInds = {};
+	}
+	getWaveUid(e) {
+		const arr = [
+			e.waveType,
+			e.withStartNodes,
+			e.markVisited,
+			e.allParentsVisited,
+			e.moveType
+		];
+		for (let node of e.nodes) arr.push(node.id);
+		return arr.join("_");
+	}
+	visitNodesByWave(e) {
+		const graph = this;
+		if (!e || !e.list || e.list.length <= 0) return;
+		if (e.waveType === graph.lastWaveType && e.waveInd < graph.lastWaveInd) return;
+		while (e.list.length) {
+			const nodeUid = e.list.shift();
+			let node = graph.nodesDict[nodeUid];
+			if (node.skipOnWaveVisit && node.skipOnWaveVisit(e)) continue;
+			if (e.markVisited) node.visited = true;
+			if (node.visitByWave) node.visitByWave(e).then(() => {
+				graph.visitNodesByWave(e);
+			});
+		}
+		if (e.afterAllVisited) e.afterAllVisited();
+	}
+	skipLink(link, waveType) {
+		return false;
+	}
+	clearWaveVisits() {
+		const graph = this;
+		for (let uid in graph.nodesDict) graph.nodesDict[uid]._waveNum = -1;
+	}
+	allParentsVisited(node, e) {
+		const graph = this;
+		for (let pid of node.parents) {
+			let link = graph.linksDict[node.id + "_" + graph.nodesDict[pid].id];
+			if (link.parent._lastWaveInd > e.waveInd && !graph.skipLink(link, e.waveType)) return false;
+		}
+		return true;
+	}
+	addChildrenToWave(parents, e) {
+		const graph = this;
+		const dubl = {};
+		for (let node of e.nodes) dubl[node.uid] = 1;
+		for (let node of parents) {
+			node._lastWaveInd = e.waveInd;
+			dubl[node.uid] = 1;
+			for (let cid of node.children) if (!dubl[cid]) {
+				dubl[cid] = 1;
+				let chNode = graph.nodesDict[cid];
+				if (chNode._lastWaveInd == null || chNode._lastWaveInd < e.waveInd) e.nodes.push(chNode);
+			}
+		}
+	}
+	triggerWave(e) {
+		if (e == null || !e.nodes || e.nodes.length <= 0) return;
+		const graph = this;
+		if (e.prepared == null) {
+			if (e.waveType == null) {
+				e.waveType = WaveType.value;
+				e.allParentsVisited = true;
+			}
+			if (e.withStartNodes == null) e.withStartNodes = true;
+			if (e.moveType == null) e.moveType = MoveType.fromParent;
+			if (e.waveInd == null) e.waveInd = ++graph.lastWaveInd;
+			e.prepared = true;
+		}
+		graph._isMakingWave = true;
+		if (graph.lastWaveInds[e.waveType] != null && e.waveInd < graph.lastWaveInds[e.waveType]) return;
+		if (graph.lastWaveInds[e.waveType] == null || graph.lastWaveInds[e.waveType] < e.waveInd) graph.lastWaveInds[e.waveType] = e.waveInd;
+		if (!e.withStartNodes) {
+			const parents = [...e.nodes];
+			e.nodes = [];
+			graph.addChildrenToWave(parents, e);
+			e.withStartNodes = true;
+		}
+		if (graph.lastWaveInds[e.waveType] == e.waveInd && e.nodes.length <= 0) {
+			graph._isMakingWave = false;
+			if (e.afterAllVisited) e.afterAllVisited();
+			return;
+		}
+		let i = 0;
+		while (i < e.nodes.length) {
+			let node = e.nodes[i];
+			if (node._lastWaveInd == e.waveInd) {
+				i++;
+				continue;
+			}
+			if (node.skipOnWaveVisit && node.skipOnWaveVisit(e)) {
+				e.nodes.splice(i, 1);
+				continue;
+			}
+			if (e.allParentsVisited && !graph.allParentsVisited(node, e)) {
+				i++;
+				continue;
+			}
+			if (e.markVisited) node.visited = true;
+			node._lastWaveInd = e.waveInd;
+			if (node.visitByWave) {
+				i++;
+				node.visitByWave(e).then(() => {
+					graph.addChildrenToWave([node], e);
+					const index = e.nodes.indexOf(node);
+					if (index > -1) e.nodes.splice(index, 1);
+					graph.triggerWave(e);
+					if (graph.lastWaveInds[e.waveType] == e.waveInd && e.nodes.length <= 0) {
+						graph._isMakingWave = false;
+						if (e.afterAllVisited) e.afterAllVisited();
+					}
+				});
+			} else {
+				e.nodes.splice(i, 1);
+				if (graph.lastWaveInds[e.waveType] == e.waveInd && e.nodes.length <= 0) {
+					graph._isMakingWave = false;
+					if (e.afterAllVisited) e.afterAllVisited();
+				}
+			}
+		}
+	}
+	triggerWaveOld(e) {
+		e = e || {};
+		const graph = this;
+		if (graph._isMakingWave || !e.nodes || e.nodes.length <= 0) return;
+		if (e.waveType == null) e.waveType = WaveType.value;
+		if (e.withStartNodes == null) e.withStartNodes = true;
+		if (e.moveType == null) e.moveType = MoveType.fromParent;
+		e.list = [];
+		e.waveUid = graph.getWaveUid(e);
+		graph.lastWaveType = e.waveType;
+		e.waveInd = ++graph.lastWaveInd;
+		graph._isMakingWave = true;
+		let _cachedWave = graph.waveCache[e.waveUid];
+		if (!graph.noCachWave && _cachedWave) {
+			Object.assign(e.list, _cachedWave);
+			graph.visitNodesByWave(e);
+			graph._isMakingWave = false;
+			return;
+		}
+		_cachedWave = [];
+		let error;
+		try {
+			graph.clearWaveVisits();
+			let waveNum = 0;
+			for (let node of e.nodes) {
+				node._waveNum = waveNum;
+				if (e.withStartNodes) _cachedWave.push(node.uid);
+			}
+			let found = true;
+			let needAdd;
+			while (found && graph.nodeCount > waveNum) {
+				found = false;
+				waveNum++;
+				const currWaveNodes = [];
+				for (let uid in graph.nodesDict) {
+					let node = graph.nodesDict[uid];
+					if (node._waveNum >= 0) continue;
+					needAdd = false;
+					if (e.moveType !== MoveType.fromChild) for (let pid of node.parents) {
+						let link = graph.linksDict[node.id + "_" + graph.nodesDict[pid].id];
+						needAdd = link.parent._waveNum >= 0 && link.parent._waveNum < waveNum && !graph.skipLink(link, e.waveType);
+						if (!e.allParentsVisited && needAdd || e.allParentsVisited && !needAdd) break;
+					}
+					if ((!needAdd || e.allParentsVisited) && e.moveType !== MoveType.fromParent) for (let cid of node.children) {
+						let link = graph.linksDict[graph.nodesDict[cid].id + "_" + node.id];
+						needAdd = link.child._waveNum >= 0 && link.child._waveNum < waveNum && !graph.skipLink(link, e.waveType);
+						if (!e.allParentsVisited && needAdd || e.allParentsVisited && !needAdd) break;
+					}
+					if (needAdd) {
+						node._waveNum = waveNum;
+						currWaveNodes.push(node);
+						found = true;
+					}
+				}
+				if (!e.allParentsVisited) {
+					let added = false;
+					for (let i = currWaveNodes.length - 1; i >= 0; i--) {
+						let node = currWaveNodes[i];
+						if (e.moveType !== MoveType.fromChild && !graph.hasParentWithSameWave(node)) {
+							_cachedWave.push(node.uid);
+							currWaveNodes.splice(i, 1);
+							added = true;
+						} else if (e.moveType !== MoveType.fromParent && !graph.hasChildWithSameWave(node)) {
+							_cachedWave.push(node.uid);
+							currWaveNodes.splice(i, 1);
+							added = true;
+						}
+					}
+					for (let node of currWaveNodes) if (!added && node.inCycle) _cachedWave.push(node.uid);
+					else node._waveNum = -1;
+				} else if (currWaveNodes.length > 0) Array.prototype.push.apply(_cachedWave, currWaveNodes);
+			}
+			Object.assign(e.list, _cachedWave);
+			graph.visitNodesByWave(e);
+		} catch (x) {
+			error = true;
+			if (graph.debug) alert(x);
+		} finally {
+			graph.clearWaveVisits();
+			graph._isMakingWave = false;
+			if (!error) graph.waveCache[e.waveUid] = _cachedWave;
+		}
+	}
+	hasParentWithSameWave(node) {
+		const graph = this;
+		if (!node) return;
+		for (let pid of node.parents) if (graph.nodesDict[pid]._waveNum === node._waveNum) return true;
+	}
+	hasChildWithSameWave(node) {
+		const graph = this;
+		if (!node) return;
+		for (let lid of node.children) if (graph.nodesDict[lid]._waveNum === node._waveNum) return true;
+	}
+	markCycles() {
+		const graph = this;
+		const hasParents = function(node) {
+			for (let pid of node.parents) if (!graph.nodesDict[pid].excluded) return true;
+		};
+		const hasChildren = function(node) {
+			for (let lid in node.children) if (graph.nodesDict[lid].excluded) return true;
+		};
+		let changesDone = true;
+		while (changesDone) {
+			changesDone = false;
+			for (let uid in graph.nodesDict) {
+				let node = graph.nodesDict[uid];
+				if (node.excluded) continue;
+				if (!hasParents(node) || !hasChildren(node)) {
+					node.excluded = true;
+					changesDone = true;
+				}
+			}
+		}
+		for (let uid in graph.nodesDict) {
+			let node = graph.nodesDict[uid];
+			if (node.excluded) delete node.excluded;
+			else node.inCycle = true;
+		}
+	}
+};
+var WaveType = class {
+	static value = 0;
+	static refresh = 1;
+	static save = 2;
+};
+var MoveType = class {
+	static fromParent = 0;
+	static fromChild = 1;
+	static All = 2;
+};
+export { GraphClass, MoveType, WaveType };

package/dist/index18.js

@@ -0,0 +1,263 @@
+var GraphClass = class {
+	constructor() {
+		const graph = this;
+		graph.nodesDict = {};
+		graph.linksDict = {};
+		graph.waveCache = {};
+		graph.nodeCount = 0;
+		graph.lastWaveInd = 0;
+		graph.lastWaveInds = {};
+	}
+	getWaveUid(e) {
+		const arr = [
+			e.waveType,
+			e.withStartNodes,
+			e.markVisited,
+			e.allParentsVisited,
+			e.moveType
+		];
+		for (let node of e.nodes) arr.push(node.id);
+		return arr.join("_");
+	}
+	visitNodesByWave(e) {
+		const graph = this;
+		if (!e || !e.list || e.list.length <= 0) return;
+		if (e.waveType === graph.lastWaveType && e.waveInd < graph.lastWaveInd) return;
+		while (e.list.length) {
+			const nodeUid = e.list.shift();
+			let node = graph.nodesDict[nodeUid];
+			if (node.skipOnWaveVisit && node.skipOnWaveVisit(e)) continue;
+			if (e.markVisited) node.visited = true;
+			if (node.visitByWave) node.visitByWave(e).then(() => {
+				graph.visitNodesByWave(e);
+			});
+		}
+		if (e.afterAllVisited) e.afterAllVisited();
+	}
+	skipLink(link, waveType) {
+		return false;
+	}
+	clearWaveVisits() {
+		const graph = this;
+		for (let uid in graph.nodesDict) graph.nodesDict[uid]._waveNum = -1;
+	}
+	allParentsVisited(node, e) {
+		const graph = this;
+		for (let pid of node.parents) {
+			let link = graph.linksDict[node.id + "_" + graph.nodesDict[pid].id];
+			if (link.parent._lastWaveInd > e.waveInd && !graph.skipLink(link, e.waveType)) return false;
+		}
+		return true;
+	}
+	addChildrenToWave(parents, e) {
+		const graph = this;
+		const dubl = {};
+		for (let node of e.nodes) dubl[node.uid] = 1;
+		for (let node of parents) {
+			node._lastWaveInd = e.waveInd;
+			dubl[node.uid] = 1;
+			for (let cid of node.children) if (!dubl[cid]) {
+				dubl[cid] = 1;
+				let chNode = graph.nodesDict[cid];
+				if (chNode._lastWaveInd == null || chNode._lastWaveInd < e.waveInd) e.nodes.push(chNode);
+			}
+		}
+	}
+	triggerWave(e) {
+		if (e == null || !e.nodes || e.nodes.length <= 0) return;
+		const graph = this;
+		if (e.prepared == null) {
+			if (e.waveType == null) {
+				e.waveType = WaveType.value;
+				e.allParentsVisited = true;
+			}
+			if (e.withStartNodes == null) e.withStartNodes = true;
+			if (e.moveType == null) e.moveType = MoveType.fromParent;
+			if (e.waveInd == null) e.waveInd = ++graph.lastWaveInd;
+			e.prepared = true;
+		}
+		graph._isMakingWave = true;
+		if (graph.lastWaveInds[e.waveType] != null && e.waveInd < graph.lastWaveInds[e.waveType]) return;
+		if (graph.lastWaveInds[e.waveType] == null || graph.lastWaveInds[e.waveType] < e.waveInd) graph.lastWaveInds[e.waveType] = e.waveInd;
+		if (!e.withStartNodes) {
+			const parents = [...e.nodes];
+			e.nodes = [];
+			graph.addChildrenToWave(parents, e);
+			e.withStartNodes = true;
+		}
+		if (graph.lastWaveInds[e.waveType] == e.waveInd && e.nodes.length <= 0) {
+			graph._isMakingWave = false;
+			if (e.afterAllVisited) e.afterAllVisited();
+			return;
+		}
+		let i = 0;
+		while (i < e.nodes.length) {
+			let node = e.nodes[i];
+			if (node._lastWaveInd == e.waveInd) {
+				i++;
+				continue;
+			}
+			if (node.skipOnWaveVisit && node.skipOnWaveVisit(e)) {
+				e.nodes.splice(i, 1);
+				continue;
+			}
+			if (e.allParentsVisited && !graph.allParentsVisited(node, e)) {
+				i++;
+				continue;
+			}
+			if (e.markVisited) node.visited = true;
+			node._lastWaveInd = e.waveInd;
+			if (node.visitByWave) {
+				i++;
+				node.visitByWave(e).then(() => {
+					graph.addChildrenToWave([node], e);
+					const index = e.nodes.indexOf(node);
+					if (index > -1) e.nodes.splice(index, 1);
+					graph.triggerWave(e);
+					if (graph.lastWaveInds[e.waveType] == e.waveInd && e.nodes.length <= 0) {
+						graph._isMakingWave = false;
+						if (e.afterAllVisited) e.afterAllVisited();
+					}
+				});
+			} else {
+				e.nodes.splice(i, 1);
+				if (graph.lastWaveInds[e.waveType] == e.waveInd && e.nodes.length <= 0) {
+					graph._isMakingWave = false;
+					if (e.afterAllVisited) e.afterAllVisited();
+				}
+			}
+		}
+	}
+	triggerWaveOld(e) {
+		e = e || {};
+		const graph = this;
+		if (graph._isMakingWave || !e.nodes || e.nodes.length <= 0) return;
+		if (e.waveType == null) e.waveType = WaveType.value;
+		if (e.withStartNodes == null) e.withStartNodes = true;
+		if (e.moveType == null) e.moveType = MoveType.fromParent;
+		e.list = [];
+		e.waveUid = graph.getWaveUid(e);
+		graph.lastWaveType = e.waveType;
+		e.waveInd = ++graph.lastWaveInd;
+		graph._isMakingWave = true;
+		let _cachedWave = graph.waveCache[e.waveUid];
+		if (!graph.noCachWave && _cachedWave) {
+			Object.assign(e.list, _cachedWave);
+			graph.visitNodesByWave(e);
+			graph._isMakingWave = false;
+			return;
+		}
+		_cachedWave = [];
+		let error;
+		try {
+			graph.clearWaveVisits();
+			let waveNum = 0;
+			for (let node of e.nodes) {
+				node._waveNum = waveNum;
+				if (e.withStartNodes) _cachedWave.push(node.uid);
+			}
+			let found = true;
+			let needAdd;
+			while (found && graph.nodeCount > waveNum) {
+				found = false;
+				waveNum++;
+				const currWaveNodes = [];
+				for (let uid in graph.nodesDict) {
+					let node = graph.nodesDict[uid];
+					if (node._waveNum >= 0) continue;
+					needAdd = false;
+					if (e.moveType !== MoveType.fromChild) for (let pid of node.parents) {
+						let link = graph.linksDict[node.id + "_" + graph.nodesDict[pid].id];
+						needAdd = link.parent._waveNum >= 0 && link.parent._waveNum < waveNum && !graph.skipLink(link, e.waveType);
+						if (!e.allParentsVisited && needAdd || e.allParentsVisited && !needAdd) break;
+					}
+					if ((!needAdd || e.allParentsVisited) && e.moveType !== MoveType.fromParent) for (let cid of node.children) {
+						let link = graph.linksDict[graph.nodesDict[cid].id + "_" + node.id];
+						needAdd = link.child._waveNum >= 0 && link.child._waveNum < waveNum && !graph.skipLink(link, e.waveType);
+						if (!e.allParentsVisited && needAdd || e.allParentsVisited && !needAdd) break;
+					}
+					if (needAdd) {
+						node._waveNum = waveNum;
+						currWaveNodes.push(node);
+						found = true;
+					}
+				}
+				if (!e.allParentsVisited) {
+					let added = false;
+					for (let i = currWaveNodes.length - 1; i >= 0; i--) {
+						let node = currWaveNodes[i];
+						if (e.moveType !== MoveType.fromChild && !graph.hasParentWithSameWave(node)) {
+							_cachedWave.push(node.uid);
+							currWaveNodes.splice(i, 1);
+							added = true;
+						} else if (e.moveType !== MoveType.fromParent && !graph.hasChildWithSameWave(node)) {
+							_cachedWave.push(node.uid);
+							currWaveNodes.splice(i, 1);
+							added = true;
+						}
+					}
+					for (let node of currWaveNodes) if (!added && node.inCycle) _cachedWave.push(node.uid);
+					else node._waveNum = -1;
+				} else if (currWaveNodes.length > 0) Array.prototype.push.apply(_cachedWave, currWaveNodes);
+			}
+			Object.assign(e.list, _cachedWave);
+			graph.visitNodesByWave(e);
+		} catch (x) {
+			error = true;
+			if (graph.debug) alert(x);
+		} finally {
+			graph.clearWaveVisits();
+			graph._isMakingWave = false;
+			if (!error) graph.waveCache[e.waveUid] = _cachedWave;
+		}
+	}
+	hasParentWithSameWave(node) {
+		const graph = this;
+		if (!node) return;
+		for (let pid of node.parents) if (graph.nodesDict[pid]._waveNum === node._waveNum) return true;
+	}
+	hasChildWithSameWave(node) {
+		const graph = this;
+		if (!node) return;
+		for (let lid of node.children) if (graph.nodesDict[lid]._waveNum === node._waveNum) return true;
+	}
+	markCycles() {
+		const graph = this;
+		const hasParents = function(node) {
+			for (let pid of node.parents) if (!graph.nodesDict[pid].excluded) return true;
+		};
+		const hasChildren = function(node) {
+			for (let lid in node.children) if (graph.nodesDict[lid].excluded) return true;
+		};
+		let changesDone = true;
+		while (changesDone) {
+			changesDone = false;
+			for (let uid in graph.nodesDict) {
+				let node = graph.nodesDict[uid];
+				if (node.excluded) continue;
+				if (!hasParents(node) || !hasChildren(node)) {
+					node.excluded = true;
+					changesDone = true;
+				}
+			}
+		}
+		for (let uid in graph.nodesDict) {
+			let node = graph.nodesDict[uid];
+			if (node.excluded) delete node.excluded;
+			else node.inCycle = true;
+		}
+	}
+};
+var WaveType = class {
+	static value = 0;
+	static refresh = 1;
+	static save = 2;
+};
+var MoveType = class {
+	static fromParent = 0;
+	static fromChild = 1;
+	static All = 2;
+};
+exports.GraphClass = GraphClass;
+exports.MoveType = MoveType;
+exports.WaveType = WaveType;