@oomol-lab/open-flow 0.1.0-beta.1 → 0.1.0-beta.10

package/dist/browser/flow-change.js

@@ -1,6 +1,26 @@
+//#region ../../node_modules/.bun/dequal@2.0.3/node_modules/dequal/lite/index.mjs
+var e = Object.prototype.hasOwnProperty;
+function t(n, r) {
+	var i, a;
+	if (n === r) return !0;
+	if (n && r && (i = n.constructor) === r.constructor) {
+		if (i === Date) return n.getTime() === r.getTime();
+		if (i === RegExp) return n.toString() === r.toString();
+		if (i === Array) {
+			if ((a = n.length) === r.length) for (; a-- && t(n[a], r[a]););
+			return a === -1;
+		}
+		if (!i || typeof n == "object") {
+			for (i in a = 0, n) if (e.call(n, i) && ++a && !e.call(r, i) || !(i in r) || !t(n[i], r[i])) return !1;
+			return Object.keys(r).length === a;
+		}
+	}
+	return n !== n && r !== r;
+}
+//#endregion
 //#region src/flow/common/change.ts
-var e = 80;
-function t(e) {
+var n = 80;
+function r(e) {
 	let t = e.trim();
 	if (t.length == 0) return "empty";
 	if (t.length > 80) return "tooLong";
@@ -10,28 +30,32 @@ function t(e) {
 	}
 	if (!/^[\p{L}\p{N}](?:[\p{L}\p{N} _-]*[\p{L}\p{N}])?$/u.test(t)) return "specialCharacter";
 }
-function n(e) {
+function i(e) {
 	return e.length <= 256 && /^[A-Za-z_][A-Za-z0-9_]*$/.test(e) && e.slice(0, 3).toUpperCase() != "OO_";
 }
-function r(e) {
+function a(e) {
 	return Object.fromEntries(e.flatMap((e) => "handle" in e ? [[e.handle, e]] : []));
 }
-var i = class extends Error {};
-function a() {
-	throw new i();
+var o = class extends Error {
+	constructor(e) {
+		super(e), this.name = "FlowChangeError";
+	}
+};
+function s(e) {
+	throw new o(e);
 }
-function o(e, t) {
+function c(e, t) {
 	if (t.kind == "flow") return e.graph;
 	let n = e.subflows[t.id];
-	return n ?? a(), n.graph;
+	return n ?? s("The target Subflow does not exist."), n.graph;
 }
-function s(e, t, n) {
+function l(e, t, n) {
 	if (t.kind == "flow") return {
 		...e,
 		graph: n
 	};
 	let r = e.subflows[t.id];
-	return r ?? a(), {
+	return r ?? s("The target Subflow does not exist."), {
 		...e,
 		subflows: {
 			...e.subflows,
@@ -42,7 +66,7 @@ function s(e, t, n) {
 		}
 	};
 }
-function c(e, t) {
+function u(e, t) {
 	if (!("inputs" in e)) return e;
 	let n = { ...e.inputs };
 	for (let [e, r] of Object.entries(n)) {
@@ -58,93 +82,129 @@ function c(e, t) {
 		inputs: n
 	};
 }
-function l(e, t) {
-	let n = { ...e.document }, r = { ...e.modules };
-	for (let e of t) switch (e.kind) {
+function d(e, n) {
+	let r = { ...e.document }, i = { ...e.modules };
+	for (let e of n) switch (e.kind) {
 		case "binding.create":
-			n.bindings[e.bindingId] != null && a(), n.bindings = {
-				...n.bindings,
-				[e.bindingId]: e.binding
-			};
-			break;
-		case "binding.replace":
-			n.bindings[e.bindingId] ?? a(), n.bindings = {
-				...n.bindings,
+			r.bindings[e.bindingId] != null && s("A Binding with this ID already exists."), r.bindings = {
+				...r.bindings,
 				[e.bindingId]: e.binding
 			};
 			break;
 		case "binding.delete": {
-			n.bindings[e.bindingId] ?? a();
-			let t = { ...n.bindings };
-			delete t[e.bindingId], n.bindings = t;
+			r.bindings[e.bindingId] ?? s("The Binding does not exist.");
+			let t = { ...r.bindings };
+			delete t[e.bindingId], r.bindings = t;
+			break;
+		}
+		case "binding.target.set": {
+			let t = r.bindings[e.bindingId];
+			t ?? s("The Binding does not exist."), t.target != e.before && s("The Binding target changed before this operation was applied."), r.bindings = {
+				...r.bindings,
+				[e.bindingId]: {
+					...t,
+					target: e.value
+				}
+			};
 			break;
 		}
 		case "graph.edge.connect": {
-			let t = o(n, e.target);
-			t.nodes[e.edge.source] ?? a();
-			let r = t.nodes[e.edge.target];
-			(r == null || !("inputs" in r)) && a();
-			let i = r.inputs[e.edge.targetHandle], c = {
+			let n = c(r, e.target);
+			n.nodes[e.edge.source] ?? s("The source Node does not exist.");
+			let i = n.nodes[e.edge.target];
+			(i == null || !("inputs" in i)) && s("The target Node does not accept inputs.");
+			let a = i.inputs[e.edge.targetHandle];
+			t(a, e.before) || s("The target input changed before this operation was applied.");
+			let o = {
 				kind: "node",
 				nodeId: e.edge.source,
 				output: e.edge.sourceHandle
-			}, l = i?.kind == "sources" ? i.sources.filter((e) => e.kind != "binding" || n.bindings[e.bindingId]?.kind != "variable") : [];
-			l.some((e) => e.kind == "node" && e.nodeId == c.nodeId && e.output == c.output) && a();
-			let u = {
-				...r,
+			}, u = a?.kind == "sources" ? a.sources.filter((e) => e.kind != "binding" || r.bindings[e.bindingId]?.kind != "variable") : [];
+			u.some((e) => e.kind == "node" && e.nodeId == o.nodeId && e.output == o.output) && s("The Nodes are already connected.");
+			let d = {
+				...i,
 				inputs: {
-					...r.inputs,
+					...i.inputs,
 					[e.edge.targetHandle]: {
 						kind: "sources",
-						sources: [...l, c]
+						sources: [...u, o]
 					}
 				}
 			};
-			Object.assign(n, s(n, e.target, { nodes: {
-				...t.nodes,
-				[e.edge.target]: u
+			Object.assign(r, l(r, e.target, { nodes: {
+				...n.nodes,
+				[e.edge.target]: d
 			} }));
 			break;
 		}
 		case "graph.edge.disconnect": {
-			let t = o(n, e.target), r = t.nodes[e.edge.target];
-			(r == null || !("inputs" in r)) && a();
-			let i = r.inputs[e.edge.targetHandle];
-			i?.kind != "sources" && a();
-			let c = i.sources.filter((t) => t.kind != "node" || t.nodeId != e.edge.source || t.output != e.edge.sourceHandle);
-			c.length == i.sources.length && a();
-			let l = { ...r.inputs };
-			c.length == 0 ? delete l[e.edge.targetHandle] : l[e.edge.targetHandle] = {
+			let n = c(r, e.target), i = n.nodes[e.edge.target];
+			(i == null || !("inputs" in i)) && s("The target Node does not accept inputs.");
+			let a = i.inputs[e.edge.targetHandle];
+			(a?.kind != "sources" || !t(a, e.before)) && s("The target input changed before this operation was applied.");
+			let o = a.sources.filter((t) => t.kind != "node" || t.nodeId != e.edge.source || t.output != e.edge.sourceHandle);
+			o.length == a.sources.length && s("The Nodes are not connected.");
+			let u = { ...i.inputs };
+			o.length == 0 ? delete u[e.edge.targetHandle] : u[e.edge.targetHandle] = {
 				kind: "sources",
-				sources: c
-			}, Object.assign(n, s(n, e.target, { nodes: {
-				...t.nodes,
+				sources: o
+			}, Object.assign(r, l(r, e.target, { nodes: {
+				...n.nodes,
 				[e.edge.target]: {
-					...r,
-					inputs: l
+					...i,
+					inputs: u
 				}
 			} }));
 			break;
 		}
+		case "graph.node.additional-inputs.set": {
+			let n = c(r, e.target), i = n.nodes[e.nodeId];
+			i?.kind != "task" && s("The Task Node does not exist."), t(i.additionalInputs, e.before) || s("The Task Node inputs changed before this operation was applied.");
+			let { additionalInputs: a, ...o } = i, u = e.value == null ? o : {
+				...o,
+				additionalInputs: e.value
+			};
+			Object.assign(r, l(r, e.target, { nodes: {
+				...n.nodes,
+				[e.nodeId]: u
+			} }));
+			break;
+		}
+		case "graph.node.condition.set": {
+			let n = c(r, e.target), i = n.nodes[e.nodeId];
+			i?.kind != "condition" && s("The Condition Node does not exist."), (!t(i.cases, e.before.cases) || i.defaultOutput != e.before.defaultOutput || !t(i.input, e.before.input)) && s("The Condition Node changed before this operation was applied.");
+			let { defaultOutput: a, ...o } = i, u = e.value.defaultOutput == null ? {
+				...o,
+				...e.value
+			} : {
+				...i,
+				...e.value
+			};
+			Object.assign(r, l(r, e.target, { nodes: {
+				...n.nodes,
+				[e.nodeId]: u
+			} }));
+			break;
+		}
 		case "graph.node.create": {
-			let t = o(n, e.target);
-			(t.nodes[e.nodeId] != null || e.target.kind == "subflow" && !("inputs" in e.node)) && a(), Object.assign(n, s(n, e.target, { nodes: {
+			let t = c(r, e.target);
+			t.nodes[e.nodeId] != null && s("A Node with this ID already exists in the target graph."), e.target.kind == "subflow" && !("inputs" in e.node) && s("Trigger Nodes cannot be created inside a Subflow."), Object.assign(r, l(r, e.target, { nodes: {
 				...t.nodes,
 				[e.nodeId]: e.node
 			} }));
 			break;
 		}
 		case "graph.node.delete": {
-			let t = o(n, e.target);
-			t.nodes[e.nodeId] ?? a();
-			let r = /* @__PURE__ */ new Set([e.nodeId]), i = Object.fromEntries(Object.entries(t.nodes).flatMap(([e, t]) => r.has(e) ? [] : [[e, c(t, r)]]));
-			if (Object.assign(n, s(n, e.target, { nodes: i })), e.target.kind == "subflow") {
-				let t = n.subflows[e.target.id], i = t.outputs.map((e) => ({
+			let t = c(r, e.target);
+			t.nodes[e.nodeId] ?? s("The Node does not exist in the target graph.");
+			let n = /* @__PURE__ */ new Set([e.nodeId]), i = Object.fromEntries(Object.entries(t.nodes).flatMap(([e, t]) => n.has(e) ? [] : [[e, u(t, n)]]));
+			if (Object.assign(r, l(r, e.target, { nodes: i })), e.target.kind == "subflow") {
+				let t = r.subflows[e.target.id], i = t.outputs.map((e) => ({
 					...e,
-					sources: e.sources.filter((e) => e.kind != "node" || !r.has(e.nodeId))
+					sources: e.sources.filter((e) => e.kind != "node" || !n.has(e.nodeId))
 				}));
-				n.subflows = {
-					...n.subflows,
+				r.subflows = {
+					...r.subflows,
 					[e.target.id]: {
 						...t,
 						outputs: i
@@ -153,82 +213,249 @@ function l(e, t) {
 			}
 			break;
 		}
-		case "graph.node.replace": {
-			let t = o(n, e.target);
-			(t.nodes[e.nodeId] == null || e.target.kind == "subflow" && !("inputs" in e.node)) && a(), Object.assign(n, s(n, e.target, { nodes: {
+		case "graph.node.field.set": {
+			let n = c(r, e.target), i = n.nodes[e.nodeId];
+			i ?? s("The Node does not exist in the target graph."), t(Reflect.get(i, e.field), e.before) || s("The Node field changed before this operation was applied."), e.field == "concurrency" && e.value == null && s("Node concurrency cannot be removed.");
+			let a = { ...i };
+			e.value == null ? Reflect.deleteProperty(a, e.field) : Object.assign(a, { [e.field]: e.value }), Object.assign(r, l(r, e.target, { nodes: {
+				...n.nodes,
+				[e.nodeId]: a
+			} }));
+			break;
+		}
+		case "graph.node.input.set": {
+			let n = c(r, e.target), i = n.nodes[e.nodeId];
+			(i == null || !("inputs" in i)) && s("The Node does not accept inputs."), t(i.inputs[e.handle], e.before) || s("The Node input changed before this operation was applied.");
+			let a = { ...i.inputs };
+			e.value == null ? delete a[e.handle] : a[e.handle] = e.value, Object.assign(r, l(r, e.target, { nodes: {
+				...n.nodes,
+				[e.nodeId]: {
+					...i,
+					inputs: a
+				}
+			} }));
+			break;
+		}
+		case "graph.node.task.name.set": {
+			let t = c(r, e.target), n = t.nodes[e.nodeId];
+			(n?.kind != "task" || n.task == null) && s("The inline Task Node does not exist."), n.task.name != e.before && s("The inline Task name changed before this operation was applied.");
+			let i = {
+				...n,
+				task: {
+					...n.task,
+					name: e.value
+				}
+			};
+			Object.assign(r, l(r, e.target, { nodes: {
 				...t.nodes,
-				[e.nodeId]: e.node
+				[e.nodeId]: i
 			} }));
 			break;
 		}
+		case "graph.node.task.ports.set": {
+			let n = c(r, e.target), i = n.nodes[e.nodeId];
+			(i?.kind != "task" || i.task == null) && s("The inline Task Node does not exist."), t({
+				inputs: i.task.inputs,
+				outputs: i.task.outputs
+			}, e.before) || s("The inline Task ports changed before this operation was applied.");
+			let a = {
+				...i,
+				task: {
+					...i.task,
+					...e.value
+				}
+			};
+			Object.assign(r, l(r, e.target, { nodes: {
+				...n.nodes,
+				[e.nodeId]: a
+			} }));
+			break;
+		}
+		case "graph.node.values.set": {
+			let n = c(r, e.target), i = n.nodes[e.nodeId];
+			i?.kind != "value" && s("The Value Node does not exist."), t(i.values, e.before) || s("The Value Node changed before this operation was applied."), Object.assign(r, l(r, e.target, { nodes: {
+				...n.nodes,
+				[e.nodeId]: {
+					...i,
+					values: e.value
+				}
+			} }));
+			break;
+		}
+		case "graph.node.wait.set": {
+			let n = r.graph, i = n.nodes[e.nodeId];
+			(i?.kind != "wait" || !t({
+				actions: i.actions,
+				...i.notification == null ? {} : { notification: i.notification },
+				prompt: i.prompt
+			}, e.before)) && s("The Wait Node changed before this operation was applied.");
+			let { notification: a, ...o } = i, c = e.value.notification == null ? {
+				...o,
+				...e.value
+			} : {
+				...i,
+				...e.value
+			};
+			r.graph = { nodes: {
+				...n.nodes,
+				[e.nodeId]: c
+			} };
+			break;
+		}
+		case "graph.node.webhook.set": {
+			let n = c(r, e.target), i = n.nodes[e.nodeId];
+			i?.kind != "webhook" && s("The Webhook Node does not exist."), (!t(i.inputsDef, e.before.inputsDef) || !t(i.options, e.before.options)) && s("The Webhook Node changed before this operation was applied.");
+			let { options: a, ...o } = i, u = e.value.options == null ? {
+				...o,
+				inputsDef: e.value.inputsDef
+			} : {
+				...i,
+				...e.value
+			};
+			Object.assign(r, l(r, e.target, { nodes: {
+				...n.nodes,
+				[e.nodeId]: u
+			} }));
+			break;
+		}
+		case "graph.trigger.config.set": {
+			let n = r.graph, i = n.nodes[e.nodeId];
+			(i == null || i.kind != "integration" && i.kind != "poll") && s("The configurable Trigger Node does not exist."), t(i.config[e.name], e.before) || s("The Trigger configuration changed before this operation was applied.");
+			let a = { ...i.config };
+			e.value === void 0 ? delete a[e.name] : a[e.name] = e.value, r.graph = { nodes: {
+				...n.nodes,
+				[e.nodeId]: {
+					...i,
+					config: a
+				}
+			} };
+			break;
+		}
+		case "graph.trigger.schedule.set": {
+			let n = r.graph, i = n.nodes[e.nodeId];
+			(i == null || i.kind != "cron" && i.kind != "poll") && s("The scheduled Trigger Node does not exist."), t(i.kind == "cron" ? i.cronTimes : i.pollTimes, e.before) || s("The Trigger schedule changed before this operation was applied.");
+			let a = i.kind == "cron" ? {
+				...i,
+				cronTimes: e.value
+			} : {
+				...i,
+				pollTimes: e.value
+			};
+			r.graph = { nodes: {
+				...n.nodes,
+				[e.nodeId]: a
+			} };
+			break;
+		}
 		case "module.create":
-			r[e.moduleId] != null && a(), r[e.moduleId] = e.module;
+			i[e.moduleId] != null && s("A CodeModule with this ID already exists."), i[e.moduleId] = e.module;
 			break;
 		case "module.delete":
-			r[e.moduleId] ?? a(), delete r[e.moduleId];
+			i[e.moduleId] ?? s("The CodeModule does not exist."), delete i[e.moduleId];
 			break;
 		case "module.rename": {
-			let t = r[e.moduleId];
-			t ?? a(), r[e.moduleId] = {
+			let t = i[e.moduleId];
+			t ?? s("The CodeModule does not exist."), t.name != e.before && s("The CodeModule name changed before this operation was applied."), i[e.moduleId] = {
 				...t,
 				name: e.name
 			};
 			break;
 		}
 		case "module.source.replace": {
-			let t = r[e.moduleId];
-			t ?? a(), r[e.moduleId] = {
-				...t,
+			let n = i[e.moduleId];
+			n ?? s("The CodeModule does not exist."), (n.source != e.beforeSource || !t(n.imports, e.beforeImports)) && s("The CodeModule source changed before this operation was applied."), i[e.moduleId] = {
+				...n,
 				imports: e.imports,
 				source: e.source
 			};
 			break;
 		}
 		case "subflow.create":
-			n.subflows[e.subflowId] != null && a(), n.subflows = {
-				...n.subflows,
+			r.subflows[e.subflowId] != null && s("A Subflow with this ID already exists."), r.subflows = {
+				...r.subflows,
 				[e.subflowId]: e.subflow
 			};
 			break;
-		case "subflow.definition.replace": {
-			let t = n.subflows[e.subflowId];
-			t ?? a(), n.subflows = {
-				...n.subflows,
+		case "subflow.definition.set": {
+			let n = r.subflows[e.subflowId];
+			n ?? s("The Subflow does not exist."), t({
+				inputs: n.inputs,
+				name: n.name,
+				outputs: n.outputs
+			}, e.before) || s("The Subflow definition changed before this operation was applied."), r.subflows = {
+				...r.subflows,
 				[e.subflowId]: {
 					...e.definition,
-					graph: t.graph
+					graph: n.graph
 				}
 			};
 			break;
 		}
 		case "subflow.delete": {
-			n.subflows[e.subflowId] ?? a();
-			let t = { ...n.subflows };
-			delete t[e.subflowId], n.subflows = t;
+			r.subflows[e.subflowId] ?? s("The Subflow does not exist.");
+			let t = { ...r.subflows };
+			delete t[e.subflowId], r.subflows = t;
 			break;
 		}
 		case "task.create":
-			n.tasks[e.taskId] != null && a(), n.tasks = {
-				...n.tasks,
+			r.tasks[e.taskId] != null && s("A Task with this ID already exists."), r.tasks = {
+				...r.tasks,
 				[e.taskId]: e.task
 			};
 			break;
+		case "task.connector.connection.set": {
+			let t = r.tasks[e.taskId];
+			(t == null || !("executor" in t) || t.executor.kind != "connector") && s("The Connector Task does not exist."), t.executor.connectionId != e.before && s("The Connector Task connection changed before this operation was applied.");
+			let { connectionId: n, ...i } = t.executor, a = e.value == null ? i : {
+				...i,
+				connectionId: e.value
+			};
+			r.tasks = {
+				...r.tasks,
+				[e.taskId]: {
+					...t,
+					executor: a
+				}
+			};
+			break;
+		}
 		case "task.delete": {
-			n.tasks[e.taskId] ?? a();
-			let t = { ...n.tasks };
-			delete t[e.taskId], n.tasks = t;
+			r.tasks[e.taskId] ?? s("The Task does not exist.");
+			let t = { ...r.tasks };
+			delete t[e.taskId], r.tasks = t;
+			break;
+		}
+		case "task.llm.mode.set": {
+			let t = r.tasks[e.taskId];
+			(t == null || !("executor" in t) || t.executor.kind != "llm") && s("The LLM Task does not exist."), t.executor.mode != e.before && s("The LLM Task mode changed before this operation was applied."), r.tasks = {
+				...r.tasks,
+				[e.taskId]: {
+					...t,
+					executor: {
+						...t.executor,
+						mode: e.value
+					}
+				}
+			};
+			break;
+		}
+		case "task.name.set": {
+			let t = r.tasks[e.taskId];
+			t ?? s("The Task does not exist."), t.name != e.before && s("The Task name changed before this operation was applied."), r.tasks = {
+				...r.tasks,
+				[e.taskId]: {
+					...t,
+					name: e.value
+				}
+			};
 			break;
 		}
-		case "task.replace": n.tasks[e.taskId] ?? a(), n.tasks = {
-			...n.tasks,
-			[e.taskId]: e.task
-		};
 	}
 	return {
-		document: n,
+		document: r,
 		modelVersion: e.modelVersion,
-		modules: r
+		modules: i
 	};
 }
 //#endregion
-export { i as FlowChangeError, l as applyFlowChanges, r as portsByHandle, t as resourceNameIssue, e as resourceNameMaxLength, n as validVariableName };
+export { o as FlowChangeError, d as applyFlowChanges, a as portsByHandle, r as resourceNameIssue, n as resourceNameMaxLength, i as validVariableName };

package/dist/browser/flow-notifications.d.ts

@@ -12,4 +12,9 @@ export type FlowChangeEvent = {
     readonly kind: 'run.created';
     readonly runId: string;
     readonly version: 1;
+} | {
+    readonly flowId: string;
+    readonly kind: 'run.changed';
+    readonly runId: string;
+    readonly version: 1;
 };