@oomol-lab/open-flow 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/browser/{markdownContent-ZZFfSRqO.js → markdownContent-BvYiwIwR.js}

@@ -1,5 +1,5 @@
 import { o as e, r as t, t as n } from "./rolldown-runtime-CEFd7nDs.js";
-import { a as r } from "./dist-n-z5HtaO.js";
+import { wn as r } from "./flowRunInputEditorStore-B49C0ZmK.js";
 import { memo as i, useEffect as a, useRef as o } from "react";
 import { Fragment as s, jsx as c, jsxs as l } from "react/jsx-runtime";
 //#region ../../node_modules/deepmerge/dist/cjs.js

package/dist/browser/project-authoring-edge.d.ts

@@ -0,0 +1,3 @@
+import type { ChangeOperation, GraphEdge, GraphTarget, RevisionContent } from './project-change.js';
+export declare function connect(content: RevisionContent, target: GraphTarget, edge: GraphEdge): readonly ChangeOperation[];
+export declare function disconnect(content: RevisionContent, target: GraphTarget, edge: GraphEdge): readonly ChangeOperation[];

package/dist/browser/project-authoring-flow.d.ts

@@ -0,0 +1,4 @@
+import type { ChangeOperation } from './project-change.js';
+export declare function createFlow(flowId: string, name: string): readonly ChangeOperation[];
+export declare function renameFlow(flowId: string, name: string): readonly ChangeOperation[];
+export declare function deleteFlow(flowId: string): readonly ChangeOperation[];

package/dist/browser/project-authoring-module.d.ts

@@ -0,0 +1,4 @@
+import type { ChangeOperation } from './project-change.js';
+export declare function imports(source: string): Promise<readonly string[]>;
+export declare function replaceSource(moduleId: string, source: string, moduleImports: readonly string[]): readonly ChangeOperation[];
+export declare function rename(moduleId: string, name: string): readonly ChangeOperation[];

package/dist/browser/project-authoring-node.d.ts

@@ -0,0 +1,90 @@
+import type { ChangeOperation, CodeModule, GraphTarget, JsonValue, PortDefinition, RevisionContent, TaskDefinition, TriggerKeySnapshot, TriggerNode, TriggerSchedule, WebhookOptions } from './project-change.js';
+export interface Settings {
+    readonly concurrency: number;
+    readonly name?: string;
+    readonly timeoutMs?: number;
+}
+export interface LlmTaskOptions {
+    readonly inputs?: Readonly<Partial<Record<LlmInputHandle, JsonValue>>>;
+    readonly output?: PortDefinition;
+}
+export type LlmInputHandle = 'input' | 'messages' | 'model' | 'template';
+interface TriggerSettingsBase {
+    readonly description?: string;
+    readonly name: string;
+}
+export type TriggerSettings = (TriggerSettingsBase & {
+    readonly inputs: Extract<TriggerNode, {
+        readonly kind: 'webhook';
+    }>['inputsDef'];
+    readonly kind: 'webhook';
+    readonly options: WebhookOptions;
+}) | (TriggerSettingsBase & {
+    readonly kind: 'cron';
+    readonly schedule: readonly TriggerSchedule[];
+}) | (TriggerSettingsBase & {
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly kind: 'poll';
+    readonly schedule: readonly TriggerSchedule[];
+}) | (TriggerSettingsBase & {
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly kind: 'integration';
+});
+export declare function createCodeTask(target: GraphTarget, identity: {
+    readonly moduleId: string;
+    readonly nodeId: string;
+}, name: string, module?: Pick<CodeModule, 'imports' | 'source'>, ports?: Pick<Extract<TaskDefinition, {
+    readonly moduleId: string;
+}>, 'inputs' | 'outputs'>): readonly ChangeOperation[];
+export declare function createManagedTask(target: GraphTarget, identity: {
+    readonly nodeId: string;
+    readonly taskId: string;
+}, task: Extract<TaskDefinition, {
+    readonly executor: unknown;
+}>): readonly ChangeOperation[];
+export declare function createLlmTask(target: GraphTarget, identity: {
+    readonly nodeId: string;
+    readonly taskId: string;
+}, name: string, mode: 'chat' | 'json', outputDescription: string, options?: LlmTaskOptions): readonly ChangeOperation[];
+export declare function createCondition(target: GraphTarget, nodeId: string, name: string): readonly ChangeOperation[];
+export declare function createValue(target: GraphTarget, nodeId: string, name: string): readonly ChangeOperation[];
+export declare function createBuiltinTrigger(target: {
+    readonly id: string;
+    readonly kind: 'flow';
+}, nodeId: string, node: Extract<TriggerNode, {
+    readonly kind: 'cron' | 'webhook';
+}>): readonly ChangeOperation[];
+export declare function createProviderTrigger(target: {
+    readonly id: string;
+    readonly kind: 'flow';
+}, identity: {
+    readonly bindingId: string;
+    readonly nodeId: string;
+}, definition: TriggerKeySnapshot, options: {
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connectionId: string;
+    readonly name?: string;
+    readonly schedule?: readonly TriggerSchedule[];
+}): readonly ChangeOperation[];
+export declare function deleteNodes(content: RevisionContent, target: GraphTarget, nodeIds: readonly string[]): readonly ChangeOperation[];
+export declare function updateSettings(content: RevisionContent, target: GraphTarget, nodeId: string, settings: Settings): readonly ChangeOperation[] | undefined;
+export declare function setInputValue(content: RevisionContent, target: GraphTarget, nodeId: string, handle: string, value: JsonValue | undefined): readonly ChangeOperation[] | undefined;
+export declare function setInputValues(content: RevisionContent, target: GraphTarget, nodeId: string, values: Readonly<Record<string, JsonValue | undefined>>): readonly ChangeOperation[] | undefined;
+export declare function setConnectorConnection(content: RevisionContent, taskId: string, connectionId: string): readonly ChangeOperation[] | undefined;
+export declare function updateTrigger(content: RevisionContent, target: {
+    readonly id: string;
+    readonly kind: 'flow';
+}, nodeId: string, settings: TriggerSettings): readonly ChangeOperation[] | undefined;
+export declare function updateTriggerConfig(content: RevisionContent, target: {
+    readonly id: string;
+    readonly kind: 'flow';
+}, nodeId: string, name: string, value: JsonValue | undefined): readonly ChangeOperation[] | undefined;
+export declare function updateTriggerSchedule(content: RevisionContent, target: {
+    readonly id: string;
+    readonly kind: 'flow';
+}, nodeId: string, schedule: readonly TriggerSchedule[]): readonly ChangeOperation[] | undefined;
+export declare function setTriggerConnection(content: RevisionContent, target: {
+    readonly id: string;
+    readonly kind: 'flow';
+}, nodeId: string, connectionId: string): readonly ChangeOperation[] | undefined;
+export {};

package/dist/browser/project-authoring.d.ts

@@ -0,0 +1,4 @@
+export { connect, disconnect } from './project-authoring-edge.js';
+export { createFlow, deleteFlow, renameFlow } from './project-authoring-flow.js';
+export { imports as moduleImports, rename as renameModule, replaceSource as replaceModuleSource } from './project-authoring-module.js';
+export { createBuiltinTrigger, createCodeTask, createCondition, createLlmTask, createManagedTask, createProviderTrigger, createValue, deleteNodes, setConnectorConnection, setInputValues, setTriggerConnection, updateSettings, updateTrigger, } from './project-authoring-node.js';

package/dist/browser/project-authoring.js

@@ -0,0 +1,426 @@
+//#region src/project/common/edgeChanges.ts
+function e(e, t, r) {
+	let i = {
+		source: r.source,
+		sourceHandle: r.sourceHandle,
+		target: r.target,
+		targetHandle: r.targetHandle
+	}, a = n(e, t)?.nodes[r.target], o = a != null && "inputs" in a ? a.inputs[r.targetHandle] : void 0;
+	return o?.kind == "sources" && o.sources.some((e) => e.kind == "node" && e.nodeId == r.source && e.output == r.sourceHandle) ? [] : [{
+		edge: i,
+		kind: "graph.edge.connect",
+		target: t
+	}];
+}
+function t(e, t, r) {
+	let i = {
+		source: r.source,
+		sourceHandle: r.sourceHandle,
+		target: r.target,
+		targetHandle: r.targetHandle
+	}, a = n(e, t)?.nodes[r.target], o = a != null && "inputs" in a ? a.inputs[r.targetHandle] : void 0;
+	return o?.kind != "sources" || !o.sources.some((e) => e.kind == "node" && e.nodeId == r.source && e.output == r.sourceHandle) ? [] : [{
+		edge: i,
+		kind: "graph.edge.disconnect",
+		target: t
+	}];
+}
+function n(e, t) {
+	return t.kind == "flow" ? e.document.flows[t.id]?.graph : e.document.subflows[t.id]?.graph;
+}
+//#endregion
+//#region src/project/common/flowChanges.ts
+function r(e, t) {
+	return [{
+		flow: {
+			graph: { nodes: {} },
+			name: t
+		},
+		flowId: e,
+		kind: "flow.create"
+	}];
+}
+function i(e, t) {
+	return [{
+		flowId: e,
+		kind: "flow.rename",
+		name: t
+	}];
+}
+function a(e) {
+	return [{
+		flowId: e,
+		kind: "flow.delete"
+	}];
+}
+//#endregion
+//#region src/project/common/moduleChanges.ts
+async function o(e) {
+	try {
+		let { parse: t } = await import("./lib-S4ccuMeT.js"), n = t(e, {
+			errorRecovery: !0,
+			sourceType: "module"
+		}).program, r = /* @__PURE__ */ new Set();
+		for (let e of n.body) {
+			if (e.type != "ImportDeclaration") continue;
+			let t = /^\.\/(.+)\.mjs$/.exec(e.source.value);
+			t?.[1] != null && r.add(t[1]);
+		}
+		return [...r].toSorted();
+	} catch {
+		return [];
+	}
+}
+function s(e, t, n) {
+	return [{
+		imports: n,
+		kind: "module.source.replace",
+		moduleId: e,
+		source: t
+	}];
+}
+function c(e, t) {
+	return [{
+		kind: "module.rename",
+		moduleId: e,
+		name: t
+	}];
+}
+//#endregion
+//#region src/project/common/nodeChanges.ts
+function l(e, t, n, r = {
+	imports: [],
+	source: "export default function run(input) {\n  return { result: input.value }\n}\n"
+}, i = {
+	inputs: { value: {
+		jsonSchema: {},
+		nullable: !0,
+		value: null
+	} },
+	outputs: { result: {
+		jsonSchema: {},
+		nullable: !0
+	} }
+}) {
+	return [{
+		kind: "module.create",
+		module: {
+			...r,
+			name: n
+		},
+		moduleId: t.moduleId
+	}, {
+		kind: "graph.node.create",
+		node: {
+			concurrency: 1,
+			inputs: C(i.inputs),
+			kind: "task",
+			name: n,
+			task: {
+				inputs: i.inputs,
+				moduleId: t.moduleId,
+				name: n,
+				outputs: i.outputs
+			}
+		},
+		nodeId: t.nodeId,
+		target: e
+	}];
+}
+function u(e, t, n) {
+	return [{
+		kind: "task.create",
+		task: n,
+		taskId: t.taskId
+	}, {
+		kind: "graph.node.create",
+		node: {
+			concurrency: 1,
+			inputs: C(n.inputs),
+			kind: "task",
+			name: n.name,
+			taskId: t.taskId
+		},
+		nodeId: t.nodeId,
+		target: e
+	}];
+}
+function d(e, t, n, r, i, a = {}) {
+	let o = a.inputs ?? {};
+	return u(e, t, {
+		executor: {
+			kind: "llm",
+			mode: r
+		},
+		inputs: {
+			messages: {
+				jsonSchema: {
+					items: { type: "object" },
+					type: "array"
+				},
+				nullable: !0,
+				value: w(o, "messages", null)
+			},
+			input: {
+				jsonSchema: { type: "string" },
+				nullable: !1,
+				value: w(o, "input", "Alex")
+			},
+			template: {
+				jsonSchema: {
+					items: { type: "object" },
+					minItems: 1,
+					type: "array"
+				},
+				nullable: !1,
+				value: w(o, "template", [{
+					content: "Hello, I'm {{input}}",
+					role: "user"
+				}])
+			},
+			model: {
+				jsonSchema: { type: "object" },
+				nullable: !1,
+				value: w(o, "model", { model: "deepseek-v4-flash" })
+			}
+		},
+		name: n,
+		outputs: { output: a.output ?? {
+			description: i,
+			jsonSchema: r == "chat" ? { type: "string" } : {},
+			nullable: !1
+		} }
+	});
+}
+function f(e, t, n) {
+	return [{
+		kind: "graph.node.create",
+		node: {
+			cases: [{
+				expressions: [{
+					input: "value",
+					operator: "isTrue"
+				}],
+				output: "true",
+				relation: "all"
+			}],
+			concurrency: 1,
+			defaultOutput: "false",
+			input: {
+				handle: "value",
+				jsonSchema: {},
+				nullable: !0,
+				value: null
+			},
+			inputs: { value: {
+				kind: "value",
+				value: null
+			} },
+			kind: "condition",
+			name: n
+		},
+		nodeId: t,
+		target: e
+	}];
+}
+function p(e, t, n) {
+	return [{
+		kind: "graph.node.create",
+		node: {
+			concurrency: 1,
+			inputs: {},
+			kind: "value",
+			name: n,
+			values: { value: {
+				jsonSchema: {},
+				nullable: !0,
+				value: null
+			} }
+		},
+		nodeId: t,
+		target: e
+	}];
+}
+function m(e, t, n) {
+	return [{
+		kind: "graph.node.create",
+		node: n,
+		nodeId: t,
+		target: e
+	}];
+}
+function h(e, t, n, r) {
+	let i = r.name ?? n.displayName, a = n.type == "poll" ? {
+		bindingId: t.bindingId,
+		config: r.config,
+		definition: n,
+		kind: "poll",
+		name: i,
+		pollTimes: r.schedule ?? [{
+			type: "every",
+			unit: "minute",
+			value: 5
+		}]
+	} : {
+		bindingId: t.bindingId,
+		config: r.config,
+		definition: n,
+		kind: "integration",
+		name: i
+	};
+	return [{
+		binding: {
+			kind: "connection",
+			target: r.connectionId
+		},
+		bindingId: t.bindingId,
+		kind: "binding.create"
+	}, {
+		kind: "graph.node.create",
+		node: a,
+		nodeId: t.nodeId,
+		target: e
+	}];
+}
+function g(e, t, n) {
+	let r = S(e, t)?.nodes;
+	if (r == null) return [];
+	let i = new Set(n), a = n.flatMap((e) => {
+		let n = r[e];
+		return n == null ? [] : [{
+			kind: "graph.node.delete",
+			nodeId: e,
+			target: t
+		}, ...n.kind == "task" && n.task != null ? [{
+			kind: "module.delete",
+			moduleId: n.task.moduleId
+		}] : []];
+	});
+	if (t.kind == "subflow") return a;
+	let o = new Set(n.flatMap((e) => {
+		let t = r[e];
+		return t?.kind == "poll" || t?.kind == "integration" ? [t.bindingId] : [];
+	}));
+	for (let n of o) Object.entries(e.document.flows).some(([e, r]) => Object.entries(r.graph.nodes).some(([r, a]) => !(e == t.id && i.has(r)) && (a.kind == "poll" || a.kind == "integration") && a.bindingId == n)) || a.push({
+		bindingId: n,
+		kind: "binding.delete"
+	});
+	return a;
+}
+function _(e, t, n, r) {
+	let i = S(e, t)?.nodes[n];
+	if (i == null || !("inputs" in i)) return;
+	let { concurrency: a, name: o, timeoutMs: s, ...c } = i;
+	return T(t, n, {
+		...c,
+		...r
+	});
+}
+function v(e, t, n, r) {
+	let i = S(e, t)?.nodes[n];
+	if (i == null || !("inputs" in i)) return;
+	let a = { ...i.inputs };
+	for (let [e, t] of Object.entries(r)) t === void 0 ? delete a[e] : a[e] = {
+		kind: "value",
+		value: t
+	};
+	return T(t, n, {
+		...i,
+		inputs: a
+	});
+}
+function y(e, t, n) {
+	let r = e.document.tasks[t];
+	if (!(r == null || !("executor" in r) || r.executor.kind != "connector")) return [{
+		kind: "task.replace",
+		task: {
+			...r,
+			executor: {
+				...r.executor,
+				connectionId: n
+			}
+		},
+		taskId: t
+	}];
+}
+function b(e, t, n, r) {
+	let i = e.document.flows[t.id]?.graph.nodes[n];
+	if (i == null) return;
+	let a = {
+		...r.description == null ? {} : { description: r.description },
+		name: r.name
+	}, o;
+	switch (r.kind) {
+		case "webhook":
+			if (i.kind != "webhook") return;
+			o = Object.keys(r.options).length == 0 ? {
+				...a,
+				inputsDef: r.inputs,
+				kind: "webhook"
+			} : {
+				...a,
+				inputsDef: r.inputs,
+				kind: "webhook",
+				options: r.options
+			};
+			break;
+		case "cron":
+			if (i.kind != "cron") return;
+			o = {
+				...a,
+				cronTimes: r.schedule,
+				kind: "cron"
+			};
+			break;
+		case "poll":
+			if (i.kind != "poll") return;
+			o = {
+				...i,
+				...a,
+				config: r.config,
+				pollTimes: r.schedule
+			};
+			break;
+		case "integration":
+			if (i.kind != "integration") return;
+			o = {
+				...i,
+				...a,
+				config: r.config
+			};
+	}
+	return T(t, n, o);
+}
+function x(e, t, n, r) {
+	let i = e.document.flows[t.id]?.graph.nodes[n];
+	if (!(i == null || i.kind != "poll" && i.kind != "integration") && e.document.bindings[i.bindingId]?.kind == "connection") return [{
+		binding: {
+			kind: "connection",
+			target: r
+		},
+		bindingId: i.bindingId,
+		kind: "binding.replace"
+	}];
+}
+function S(e, t) {
+	return t.kind == "flow" ? e.document.flows[t.id]?.graph : e.document.subflows[t.id]?.graph;
+}
+function C(e) {
+	return Object.fromEntries(Object.entries(e).flatMap(([e, t]) => Object.hasOwn(t, "value") ? [[e, {
+		kind: "value",
+		value: t.value
+	}]] : []));
+}
+function w(e, t, n) {
+	return e != null && Object.hasOwn(e, t) ? e[t] : n;
+}
+function T(e, t, n) {
+	return [{
+		kind: "graph.node.replace",
+		node: n,
+		nodeId: t,
+		target: e
+	}];
+}
+//#endregion
+export { e as connect, m as createBuiltinTrigger, l as createCodeTask, f as createCondition, r as createFlow, d as createLlmTask, u as createManagedTask, h as createProviderTrigger, p as createValue, a as deleteFlow, g as deleteNodes, t as disconnect, o as moduleImports, i as renameFlow, c as renameModule, s as replaceModuleSource, y as setConnectorConnection, v as setInputValues, x as setTriggerConnection, _ as updateSettings, b as updateTrigger };

package/dist/browser/workbench-contract.d.ts

@@ -8,7 +8,6 @@ export interface WorkbenchNotification {
     readonly message: string;
 }
 export interface WorkbenchHost {
-    readonly returnUrl: string;
     notify(notification: WorkbenchNotification | undefined): void;
     openExternalPage(resolveUrl: () => Promise<string>): Promise<boolean>;
     request(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;