290 lines
13 KiB
JavaScript
290 lines
13 KiB
JavaScript
var IoDirection;
|
|
(function (IoDirection) {
|
|
IoDirection[IoDirection["INPUT"] = 0] = "INPUT";
|
|
IoDirection[IoDirection["OUTPUT"] = 1] = "OUTPUT";
|
|
})(IoDirection || (IoDirection = {}));
|
|
function getNodeById(graph, id) {
|
|
if (graph.getNodeById) {
|
|
return graph.getNodeById(id);
|
|
}
|
|
graph = graph;
|
|
return graph.nodes.find((n) => n.id === id);
|
|
}
|
|
function extendLink(link) {
|
|
return {
|
|
link: link,
|
|
id: link[0],
|
|
origin_id: link[1],
|
|
origin_slot: link[2],
|
|
target_id: link[3],
|
|
target_slot: link[4],
|
|
type: link[5],
|
|
};
|
|
}
|
|
export function fixBadLinks(graph, fix = false, silent = false, logger = console) {
|
|
var _a, _b;
|
|
const patchedNodeSlots = {};
|
|
const data = {
|
|
patchedNodes: [],
|
|
deletedLinks: [],
|
|
};
|
|
async function patchNodeSlot(node, ioDir, slot, linkId, op) {
|
|
var _a, _b, _c;
|
|
patchedNodeSlots[node.id] = patchedNodeSlots[node.id] || {};
|
|
const patchedNode = patchedNodeSlots[node.id];
|
|
if (ioDir == IoDirection.INPUT) {
|
|
patchedNode["inputs"] = patchedNode["inputs"] || {};
|
|
if (patchedNode["inputs"][slot] !== undefined) {
|
|
!silent &&
|
|
logger.log(` > Already set ${node.id}.inputs[${slot}] to ${patchedNode["inputs"][slot]} Skipping.`);
|
|
return false;
|
|
}
|
|
let linkIdToSet = op === "REMOVE" ? null : linkId;
|
|
patchedNode["inputs"][slot] = linkIdToSet;
|
|
if (fix) {
|
|
}
|
|
}
|
|
else {
|
|
patchedNode["outputs"] = patchedNode["outputs"] || {};
|
|
patchedNode["outputs"][slot] = patchedNode["outputs"][slot] || {
|
|
links: [...(((_b = (_a = node.outputs) === null || _a === void 0 ? void 0 : _a[slot]) === null || _b === void 0 ? void 0 : _b.links) || [])],
|
|
changes: {},
|
|
};
|
|
if (patchedNode["outputs"][slot]["changes"][linkId] !== undefined) {
|
|
!silent &&
|
|
logger.log(` > Already set ${node.id}.outputs[${slot}] to ${patchedNode["inputs"][slot]}! Skipping.`);
|
|
return false;
|
|
}
|
|
patchedNode["outputs"][slot]["changes"][linkId] = op;
|
|
if (op === "ADD") {
|
|
let linkIdIndex = patchedNode["outputs"][slot]["links"].indexOf(linkId);
|
|
if (linkIdIndex !== -1) {
|
|
!silent && logger.log(` > Hmmm.. asked to add ${linkId} but it is already in list...`);
|
|
return false;
|
|
}
|
|
patchedNode["outputs"][slot]["links"].push(linkId);
|
|
if (fix) {
|
|
node.outputs = node.outputs || [];
|
|
node.outputs[slot] = node.outputs[slot] || {};
|
|
node.outputs[slot].links = node.outputs[slot].links || [];
|
|
node.outputs[slot].links.push(linkId);
|
|
}
|
|
}
|
|
else {
|
|
let linkIdIndex = patchedNode["outputs"][slot]["links"].indexOf(linkId);
|
|
if (linkIdIndex === -1) {
|
|
!silent && logger.log(` > Hmmm.. asked to remove ${linkId} but it doesn't exist...`);
|
|
return false;
|
|
}
|
|
patchedNode["outputs"][slot]["links"].splice(linkIdIndex, 1);
|
|
if (fix) {
|
|
(_c = node.outputs) === null || _c === void 0 ? void 0 : _c[slot].links.splice(linkIdIndex, 1);
|
|
}
|
|
}
|
|
}
|
|
data.patchedNodes.push(node);
|
|
return true;
|
|
}
|
|
function nodeHasLinkId(node, ioDir, slot, linkId) {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
|
|
let has = false;
|
|
if (ioDir === IoDirection.INPUT) {
|
|
let nodeHasIt = ((_b = (_a = node.inputs) === null || _a === void 0 ? void 0 : _a[slot]) === null || _b === void 0 ? void 0 : _b.link) === linkId;
|
|
if ((_c = patchedNodeSlots[node.id]) === null || _c === void 0 ? void 0 : _c["inputs"]) {
|
|
let patchedHasIt = patchedNodeSlots[node.id]["inputs"][slot] === linkId;
|
|
if (fix && nodeHasIt !== patchedHasIt) {
|
|
throw Error("Error. Expected node to match patched data.");
|
|
}
|
|
has = patchedHasIt;
|
|
}
|
|
else {
|
|
has = !!nodeHasIt;
|
|
}
|
|
}
|
|
else {
|
|
let nodeHasIt = (_f = (_e = (_d = node.outputs) === null || _d === void 0 ? void 0 : _d[slot]) === null || _e === void 0 ? void 0 : _e.links) === null || _f === void 0 ? void 0 : _f.includes(linkId);
|
|
if ((_j = (_h = (_g = patchedNodeSlots[node.id]) === null || _g === void 0 ? void 0 : _g["outputs"]) === null || _h === void 0 ? void 0 : _h[slot]) === null || _j === void 0 ? void 0 : _j["changes"][linkId]) {
|
|
let patchedHasIt = (_k = patchedNodeSlots[node.id]["outputs"][slot]) === null || _k === void 0 ? void 0 : _k.links.includes(linkId);
|
|
if (fix && nodeHasIt !== patchedHasIt) {
|
|
throw Error("Error. Expected node to match patched data.");
|
|
}
|
|
has = !!patchedHasIt;
|
|
}
|
|
else {
|
|
has = !!nodeHasIt;
|
|
}
|
|
}
|
|
return has;
|
|
}
|
|
function nodeHasAnyLink(node, ioDir, slot) {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
|
|
let hasAny = false;
|
|
if (ioDir === IoDirection.INPUT) {
|
|
let nodeHasAny = ((_b = (_a = node.inputs) === null || _a === void 0 ? void 0 : _a[slot]) === null || _b === void 0 ? void 0 : _b.link) != null;
|
|
if ((_c = patchedNodeSlots[node.id]) === null || _c === void 0 ? void 0 : _c["inputs"]) {
|
|
let patchedHasAny = patchedNodeSlots[node.id]["inputs"][slot] != null;
|
|
if (fix && nodeHasAny !== patchedHasAny) {
|
|
throw Error("Error. Expected node to match patched data.");
|
|
}
|
|
hasAny = patchedHasAny;
|
|
}
|
|
else {
|
|
hasAny = !!nodeHasAny;
|
|
}
|
|
}
|
|
else {
|
|
let nodeHasAny = (_f = (_e = (_d = node.outputs) === null || _d === void 0 ? void 0 : _d[slot]) === null || _e === void 0 ? void 0 : _e.links) === null || _f === void 0 ? void 0 : _f.length;
|
|
if ((_j = (_h = (_g = patchedNodeSlots[node.id]) === null || _g === void 0 ? void 0 : _g["outputs"]) === null || _h === void 0 ? void 0 : _h[slot]) === null || _j === void 0 ? void 0 : _j["changes"]) {
|
|
let patchedHasAny = (_k = patchedNodeSlots[node.id]["outputs"][slot]) === null || _k === void 0 ? void 0 : _k.links.length;
|
|
if (fix && nodeHasAny !== patchedHasAny) {
|
|
throw Error("Error. Expected node to match patched data.");
|
|
}
|
|
hasAny = !!patchedHasAny;
|
|
}
|
|
else {
|
|
hasAny = !!nodeHasAny;
|
|
}
|
|
}
|
|
return hasAny;
|
|
}
|
|
let links = [];
|
|
if (!Array.isArray(graph.links)) {
|
|
Object.values(graph.links).reduce((acc, v) => {
|
|
acc[v.id] = v;
|
|
return acc;
|
|
}, links);
|
|
}
|
|
else {
|
|
links = graph.links;
|
|
}
|
|
const linksReverse = [...links];
|
|
linksReverse.reverse();
|
|
for (let l of linksReverse) {
|
|
if (!l)
|
|
continue;
|
|
const link = l.origin_slot != null ? l : extendLink(l);
|
|
const originNode = getNodeById(graph, link.origin_id);
|
|
const originHasLink = () => nodeHasLinkId(originNode, IoDirection.OUTPUT, link.origin_slot, link.id);
|
|
const patchOrigin = (op, id = link.id) => patchNodeSlot(originNode, IoDirection.OUTPUT, link.origin_slot, id, op);
|
|
const targetNode = getNodeById(graph, link.target_id);
|
|
const targetHasLink = () => nodeHasLinkId(targetNode, IoDirection.INPUT, link.target_slot, link.id);
|
|
const targetHasAnyLink = () => nodeHasAnyLink(targetNode, IoDirection.INPUT, link.target_slot);
|
|
const patchTarget = (op, id = link.id) => patchNodeSlot(targetNode, IoDirection.INPUT, link.target_slot, id, op);
|
|
const originLog = `origin(${link.origin_id}).outputs[${link.origin_slot}].links`;
|
|
const targetLog = `target(${link.target_id}).inputs[${link.target_slot}].link`;
|
|
if (!originNode || !targetNode) {
|
|
if (!originNode && !targetNode) {
|
|
!silent &&
|
|
logger.log(`Link ${link.id} is invalid, ` +
|
|
`both origin ${link.origin_id} and target ${link.target_id} do not exist`);
|
|
}
|
|
else if (!originNode) {
|
|
!silent &&
|
|
logger.log(`Link ${link.id} is funky... ` +
|
|
`origin ${link.origin_id} does not exist, but target ${link.target_id} does.`);
|
|
if (targetHasLink()) {
|
|
!silent &&
|
|
logger.log(` > [PATCH] ${targetLog} does have link, will remove the inputs' link first.`);
|
|
patchTarget("REMOVE", -1);
|
|
}
|
|
}
|
|
else if (!targetNode) {
|
|
!silent &&
|
|
logger.log(`Link ${link.id} is funky... ` +
|
|
`target ${link.target_id} does not exist, but origin ${link.origin_id} does.`);
|
|
if (originHasLink()) {
|
|
!silent &&
|
|
logger.log(` > [PATCH] Origin's links' has ${link.id}; will remove the link first.`);
|
|
patchOrigin("REMOVE");
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
if (targetHasLink() || originHasLink()) {
|
|
if (!originHasLink()) {
|
|
!silent &&
|
|
logger.log(`${link.id} is funky... ${originLog} does NOT contain it, but ${targetLog} does.`);
|
|
!silent &&
|
|
logger.log(` > [PATCH] Attempt a fix by adding this ${link.id} to ${originLog}.`);
|
|
patchOrigin("ADD");
|
|
}
|
|
else if (!targetHasLink()) {
|
|
!silent &&
|
|
logger.log(`${link.id} is funky... ${targetLog} is NOT correct (is ${(_b = (_a = targetNode.inputs) === null || _a === void 0 ? void 0 : _a[link.target_slot]) === null || _b === void 0 ? void 0 : _b.link}), but ${originLog} contains it`);
|
|
if (!targetHasAnyLink()) {
|
|
!silent && logger.log(` > [PATCH] ${targetLog} is not defined, will set to ${link.id}.`);
|
|
let patched = patchTarget("ADD");
|
|
if (!patched) {
|
|
!silent &&
|
|
logger.log(` > [PATCH] Nvm, ${targetLog} already patched. Removing ${link.id} from ${originLog}.`);
|
|
patched = patchOrigin("REMOVE");
|
|
}
|
|
}
|
|
else {
|
|
!silent &&
|
|
logger.log(` > [PATCH] ${targetLog} is defined, removing ${link.id} from ${originLog}.`);
|
|
patchOrigin("REMOVE");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (let l of linksReverse) {
|
|
if (!l)
|
|
continue;
|
|
const link = l.origin_slot != null ? l : extendLink(l);
|
|
const originNode = getNodeById(graph, link.origin_id);
|
|
const targetNode = getNodeById(graph, link.target_id);
|
|
if ((!originNode || !nodeHasLinkId(originNode, IoDirection.OUTPUT, link.origin_slot, link.id)) &&
|
|
(!targetNode || !nodeHasLinkId(targetNode, IoDirection.INPUT, link.target_slot, link.id))) {
|
|
!silent &&
|
|
logger.log(`${link.id} is def invalid; BOTH origin node ${link.origin_id} ${!originNode ? "is removed" : `doesn\'t have ${link.id}`} and ${link.origin_id} target node ${!targetNode ? "is removed" : `doesn\'t have ${link.id}`}.`);
|
|
data.deletedLinks.push(link.id);
|
|
continue;
|
|
}
|
|
}
|
|
if (fix) {
|
|
for (let i = data.deletedLinks.length - 1; i >= 0; i--) {
|
|
!silent && logger.log(`Deleting link #${data.deletedLinks[i]}.`);
|
|
if (graph.getNodeById) {
|
|
delete graph.links[data.deletedLinks[i]];
|
|
}
|
|
else {
|
|
graph = graph;
|
|
const idx = graph.links.findIndex((l) => l && (l[0] === data.deletedLinks[i] || l.id === data.deletedLinks[i]));
|
|
if (idx === -1) {
|
|
logger.log(`INDEX NOT FOUND for #${data.deletedLinks[i]}`);
|
|
}
|
|
logger.log(`splicing ${idx} from links`);
|
|
graph.links.splice(idx, 1);
|
|
}
|
|
}
|
|
if (!graph.getNodeById) {
|
|
graph.links = graph.links.filter((l) => !!l);
|
|
}
|
|
}
|
|
if (!data.patchedNodes.length && !data.deletedLinks.length) {
|
|
!silent && logger.log(`No bad links detected.`);
|
|
return {
|
|
hasBadLinks: false,
|
|
fixed: false,
|
|
graph,
|
|
patched: data.patchedNodes.length,
|
|
deleted: data.deletedLinks.length,
|
|
};
|
|
}
|
|
!silent &&
|
|
logger.log(`${fix ? "Made" : "Would make"} ${data.patchedNodes.length || "no"} node link patches, and ${data.deletedLinks.length || "no"} stale link removals.`);
|
|
let hasBadLinks = !!(data.patchedNodes.length || data.deletedLinks.length);
|
|
if (fix && !silent) {
|
|
const rerun = fixBadLinks(graph, false, true);
|
|
hasBadLinks = rerun.hasBadLinks;
|
|
}
|
|
return {
|
|
hasBadLinks,
|
|
fixed: !!hasBadLinks && fix,
|
|
graph,
|
|
patched: data.patchedNodes.length,
|
|
deleted: data.deletedLinks.length,
|
|
};
|
|
}
|