@oomol-lab/open-flow 0.1.0-alpha.0

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

@@ -0,0 +1,311 @@
+export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+export declare const resourceNameMaxLength = 80;
+export type ResourceNameIssue = 'controlCharacter' | 'empty' | 'specialCharacter' | 'tooLong';
+export declare function resourceNameIssue(value: string): ResourceNameIssue | undefined;
+export interface PortDefinition {
+    readonly description?: string;
+    readonly jsonSchema: JsonValue;
+    readonly nullable: boolean;
+}
+export interface InputPortDefinition extends PortDefinition {
+    readonly value?: JsonValue;
+}
+export interface NodeSource {
+    readonly kind: 'node';
+    readonly nodeId: string;
+    readonly output: string;
+}
+export interface FlowSource {
+    readonly input: string;
+    readonly kind: 'flow';
+}
+export interface BindingSource {
+    readonly bindingId: string;
+    readonly kind: 'binding';
+}
+export type InputMapping = {
+    readonly kind: 'sources';
+    readonly sources: readonly (BindingSource | FlowSource | NodeSource)[];
+} | {
+    readonly kind: 'value';
+    readonly value: JsonValue;
+};
+export interface OutputMapping {
+    readonly sources: readonly (FlowSource | NodeSource)[];
+}
+interface GraphNodeBase {
+    readonly concurrency: number;
+    readonly description?: string;
+    readonly inputs: Readonly<Record<string, InputMapping>>;
+    readonly name?: string;
+    readonly timeoutMs?: number;
+}
+export interface SubflowNode extends GraphNodeBase {
+    readonly kind: 'subflow';
+    readonly subflowId: string;
+}
+export interface ValueNode extends GraphNodeBase {
+    readonly kind: 'value';
+    readonly values: Readonly<Record<string, InputPortDefinition>>;
+}
+export type ConditionOperator = '!=' | '<' | '<=' | '==' | '>' | '>=' | 'contains' | 'endsWith' | 'hasKey' | 'hasValue' | 'isEmpty' | 'isFalse' | 'isNotEmpty' | 'isNotNull' | 'isNull' | 'isTrue' | 'notContains' | 'notHasKey' | 'notHasValue' | 'startsWith';
+export interface ConditionExpression {
+    readonly input: string;
+    readonly operator: ConditionOperator;
+    readonly value?: JsonValue;
+}
+export interface ConditionCase {
+    readonly expressions: readonly ConditionExpression[];
+    readonly output: string;
+    readonly relation: 'all' | 'any';
+}
+export interface ConditionNode extends GraphNodeBase {
+    readonly cases: readonly ConditionCase[];
+    readonly defaultOutput?: string;
+    readonly input: InputPortDefinition & {
+        readonly handle: string;
+    };
+    readonly kind: 'condition';
+}
+export type ManagedTaskExecutor = {
+    readonly kind: 'connector';
+    readonly action: string;
+    readonly connectionId?: string;
+} | {
+    readonly kind: 'llm';
+    readonly mode: 'chat' | 'json';
+};
+export interface ConnectorCapability {
+    readonly action: string;
+    readonly connectionId: string;
+    readonly kind: 'connector';
+}
+interface TaskDefinitionBase {
+    readonly inputs: Readonly<Record<string, InputPortDefinition>>;
+    readonly name: string;
+    readonly outputs: Readonly<Record<string, PortDefinition>>;
+}
+export interface InlineTaskDefinition extends TaskDefinitionBase {
+    readonly capabilities?: readonly ConnectorCapability[];
+    readonly moduleId: string;
+}
+export interface ManagedTaskDefinition extends TaskDefinitionBase {
+    readonly executor: ManagedTaskExecutor;
+}
+export type TaskDefinition = InlineTaskDefinition | ManagedTaskDefinition;
+export type TaskNode = GraphNodeBase & {
+    readonly kind: 'task';
+} & ({
+    readonly task: InlineTaskDefinition;
+    readonly taskId?: never;
+} | {
+    readonly task?: never;
+    readonly taskId: string;
+});
+export interface Graph {
+    readonly nodes: Readonly<Record<string, GraphNode>>;
+}
+export type TriggerSchedule = {
+    readonly expression: string;
+    readonly timezone: string;
+    readonly type: 'cron';
+} | {
+    readonly type: 'every';
+    readonly unit: 'day' | 'hour' | 'minute' | 'month' | 'week';
+    readonly value: number;
+};
+interface TriggerKeySnapshotBase {
+    readonly configSchema: JsonValue;
+    readonly definitionVersion: number;
+    readonly description: string;
+    readonly displayName: string;
+    readonly key: string;
+    readonly name: string;
+    readonly payloadSchema: JsonValue;
+    readonly provider: string;
+}
+export type IntegrationEndpointMethod = 'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT';
+export type IntegrationBodyFormat = 'form' | 'json' | 'multipart' | 'text';
+export interface IntegrationEndpointDeclaration {
+    readonly body: {
+        readonly allowArray: boolean;
+        readonly allowEmpty: boolean;
+        readonly formats: readonly IntegrationBodyFormat[];
+    };
+    readonly methods: readonly IntegrationEndpointMethod[];
+    readonly successStatus: number;
+}
+export type TriggerKeySnapshot = (TriggerKeySnapshotBase & {
+    readonly type: 'poll';
+}) | (TriggerKeySnapshotBase & {
+    readonly endpoint: IntegrationEndpointDeclaration;
+    readonly type: 'integration';
+});
+export interface WebhookInputDefinition extends InputPortDefinition {
+    readonly handle: string;
+}
+export interface WebhookOptions {
+    readonly allowedMethods?: readonly string[];
+    readonly allowedOrigins?: readonly string[];
+    readonly noResponseBody?: boolean;
+    readonly responseData?: string;
+    readonly responseHeaders?: Readonly<Record<string, string>>;
+    readonly responseStatusCode?: number;
+}
+interface TriggerNodeBase {
+    readonly description?: string;
+    readonly name: string;
+}
+export type TriggerNode = (TriggerNodeBase & {
+    readonly inputsDef: readonly WebhookInputDefinition[];
+    readonly kind: 'webhook';
+    readonly options?: WebhookOptions;
+}) | (TriggerNodeBase & {
+    readonly cronTimes: readonly TriggerSchedule[];
+    readonly kind: 'cron';
+}) | (TriggerNodeBase & {
+    readonly bindingId: string;
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly definition: TriggerKeySnapshot & {
+        readonly type: 'poll';
+    };
+    readonly kind: 'poll';
+    readonly pollTimes: readonly TriggerSchedule[];
+}) | (TriggerNodeBase & {
+    readonly bindingId: string;
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly definition: TriggerKeySnapshot & {
+        readonly type: 'integration';
+    };
+    readonly kind: 'integration';
+});
+export type GraphNode = ConditionNode | SubflowNode | TaskNode | TriggerNode | ValueNode;
+export interface ProjectDocument {
+    readonly bindings: Readonly<Record<string, {
+        readonly kind: 'connection' | 'secret';
+        readonly target: string;
+    }>>;
+    readonly flows: Readonly<Record<string, {
+        readonly graph: Graph;
+        readonly name: string;
+    }>>;
+    readonly subflows: Readonly<Record<string, {
+        readonly graph: Graph;
+        readonly inputs: Readonly<Record<string, InputPortDefinition>>;
+        readonly name: string;
+        readonly outputs: Readonly<Record<string, OutputMapping & PortDefinition>>;
+    }>>;
+    readonly tasks: Readonly<Record<string, ManagedTaskDefinition>>;
+}
+export interface CodeModule {
+    readonly imports: readonly string[];
+    readonly name: string;
+    readonly source: string;
+}
+export interface RevisionContent {
+    readonly document: ProjectDocument;
+    readonly modelVersion: 1;
+    readonly modules: Readonly<Record<string, CodeModule>>;
+}
+export type GraphTarget = {
+    readonly id: string;
+    readonly kind: 'flow';
+} | {
+    readonly id: string;
+    readonly kind: 'subflow';
+};
+export interface GraphEdge {
+    readonly source: string;
+    readonly sourceHandle: string;
+    readonly target: string;
+    readonly targetHandle: string;
+}
+export type ChangeOperation = {
+    readonly binding: ProjectDocument['bindings'][string];
+    readonly bindingId: string;
+    readonly kind: 'binding.create';
+} | {
+    readonly binding: ProjectDocument['bindings'][string];
+    readonly bindingId: string;
+    readonly kind: 'binding.replace';
+} | {
+    readonly bindingId: string;
+    readonly kind: 'binding.delete';
+} | {
+    readonly flow: ProjectDocument['flows'][string];
+    readonly flowId: string;
+    readonly kind: 'flow.create';
+} | {
+    readonly flowId: string;
+    readonly kind: 'flow.delete';
+} | {
+    readonly flowId: string;
+    readonly kind: 'flow.rename';
+    readonly name: string;
+} | {
+    readonly kind: 'graph.edge.connect';
+    readonly edge: GraphEdge;
+    readonly target: GraphTarget;
+} | {
+    readonly kind: 'graph.edge.disconnect';
+    readonly edge: GraphEdge;
+    readonly target: GraphTarget;
+} | {
+    readonly kind: 'graph.node.create';
+    readonly node: GraphNode;
+    readonly nodeId: string;
+    readonly target: GraphTarget;
+} | {
+    readonly kind: 'graph.node.delete';
+    readonly nodeId: string;
+    readonly target: GraphTarget;
+} | {
+    readonly kind: 'graph.node.replace';
+    readonly node: GraphNode;
+    readonly nodeId: string;
+    readonly target: GraphTarget;
+} | {
+    readonly kind: 'module.create';
+    readonly module: CodeModule;
+    readonly moduleId: string;
+} | {
+    readonly kind: 'module.delete';
+    readonly moduleId: string;
+} | {
+    readonly kind: 'module.rename';
+    readonly moduleId: string;
+    readonly name: string;
+} | {
+    readonly imports: readonly string[];
+    readonly kind: 'module.source.replace';
+    readonly moduleId: string;
+    readonly source: string;
+} | {
+    readonly kind: 'subflow.create';
+    readonly subflow: ProjectDocument['subflows'][string];
+    readonly subflowId: string;
+} | {
+    readonly definition: Omit<ProjectDocument['subflows'][string], 'graph'>;
+    readonly kind: 'subflow.definition.replace';
+    readonly subflowId: string;
+} | {
+    readonly kind: 'subflow.delete';
+    readonly subflowId: string;
+} | {
+    readonly kind: 'task.create';
+    readonly task: ProjectDocument['tasks'][string];
+    readonly taskId: string;
+} | {
+    readonly kind: 'task.delete';
+    readonly taskId: string;
+} | {
+    readonly kind: 'task.replace';
+    readonly task: ProjectDocument['tasks'][string];
+    readonly taskId: string;
+};
+export declare class ProjectChangeError extends Error {
+}
+export declare function applyProjectChanges(content: RevisionContent, operations: readonly ChangeOperation[]): RevisionContent;
+export {};

package/dist/browser/project-change.js

@@ -0,0 +1,259 @@
+//#region src/project/common/change.ts
+var e = 80;
+function t(e) {
+	let t = e.trim();
+	if (t.length == 0) return "empty";
+	if (t.length > 80) return "tooLong";
+	for (let e of t) {
+		let t = e.charCodeAt(0);
+		if (t <= 31 || t >= 127 && t <= 159) return "controlCharacter";
+	}
+	if (!/^[\p{L}\p{N}](?:[\p{L}\p{N} _-]*[\p{L}\p{N}])?$/u.test(t)) return "specialCharacter";
+}
+var n = class extends Error {};
+function r() {
+	throw new n();
+}
+function i(e, t) {
+	let n = t.kind == "flow" ? e.flows[t.id] : e.subflows[t.id];
+	return n ?? r(), n.graph;
+}
+function a(e, t, n) {
+	if (t.kind == "flow") {
+		let i = e.flows[t.id];
+		return i ?? r(), {
+			...e,
+			flows: {
+				...e.flows,
+				[t.id]: {
+					...i,
+					graph: n
+				}
+			}
+		};
+	}
+	let i = e.subflows[t.id];
+	return i ?? r(), {
+		...e,
+		subflows: {
+			...e.subflows,
+			[t.id]: {
+				...i,
+				graph: n
+			}
+		}
+	};
+}
+function o(e, t) {
+	if (!("inputs" in e)) return e;
+	let n = { ...e.inputs };
+	for (let [e, r] of Object.entries(n)) {
+		if (r.kind != "sources") continue;
+		let i = r.sources.filter((e) => e.kind != "node" || !t.has(e.nodeId));
+		i.length == 0 ? delete n[e] : n[e] = {
+			kind: "sources",
+			sources: i
+		};
+	}
+	return {
+		...e,
+		inputs: n
+	};
+}
+function s(e, t) {
+	let n = { ...e.document }, s = { ...e.modules };
+	for (let e of t) switch (e.kind) {
+		case "binding.create":
+			n.bindings[e.bindingId] != null && r(), n.bindings = {
+				...n.bindings,
+				[e.bindingId]: e.binding
+			};
+			break;
+		case "binding.replace":
+			n.bindings[e.bindingId] ?? r(), n.bindings = {
+				...n.bindings,
+				[e.bindingId]: e.binding
+			};
+			break;
+		case "binding.delete": {
+			n.bindings[e.bindingId] ?? r();
+			let t = { ...n.bindings };
+			delete t[e.bindingId], n.bindings = t;
+			break;
+		}
+		case "flow.create":
+			n.flows[e.flowId] != null && r(), n.flows = {
+				...n.flows,
+				[e.flowId]: e.flow
+			};
+			break;
+		case "flow.delete": {
+			n.flows[e.flowId] ?? r();
+			let t = { ...n.flows };
+			delete t[e.flowId], n.flows = t;
+			break;
+		}
+		case "flow.rename": {
+			let t = n.flows[e.flowId];
+			t ?? r(), n.flows = {
+				...n.flows,
+				[e.flowId]: {
+					...t,
+					name: e.name
+				}
+			};
+			break;
+		}
+		case "graph.edge.connect": {
+			let t = i(n, e.target);
+			t.nodes[e.edge.source] ?? r();
+			let o = t.nodes[e.edge.target];
+			(o == null || !("inputs" in o)) && r();
+			let s = o.inputs[e.edge.targetHandle], c = {
+				kind: "node",
+				nodeId: e.edge.source,
+				output: e.edge.sourceHandle
+			}, l = s?.kind == "sources" ? s.sources : [];
+			l.some((e) => e.kind == "node" && e.nodeId == c.nodeId && e.output == c.output) && r();
+			let u = {
+				...o,
+				inputs: {
+					...o.inputs,
+					[e.edge.targetHandle]: {
+						kind: "sources",
+						sources: [...l, c]
+					}
+				}
+			};
+			Object.assign(n, a(n, e.target, { nodes: {
+				...t.nodes,
+				[e.edge.target]: u
+			} }));
+			break;
+		}
+		case "graph.edge.disconnect": {
+			let t = i(n, e.target), o = t.nodes[e.edge.target];
+			(o == null || !("inputs" in o)) && r();
+			let s = o.inputs[e.edge.targetHandle];
+			s?.kind != "sources" && r();
+			let c = s.sources.filter((t) => t.kind != "node" || t.nodeId != e.edge.source || t.output != e.edge.sourceHandle);
+			c.length == s.sources.length && r();
+			let l = { ...o.inputs };
+			c.length == 0 ? delete l[e.edge.targetHandle] : l[e.edge.targetHandle] = {
+				kind: "sources",
+				sources: c
+			}, Object.assign(n, a(n, e.target, { nodes: {
+				...t.nodes,
+				[e.edge.target]: {
+					...o,
+					inputs: l
+				}
+			} }));
+			break;
+		}
+		case "graph.node.create": {
+			let t = i(n, e.target);
+			(t.nodes[e.nodeId] != null || e.target.kind == "subflow" && !("inputs" in e.node)) && r(), Object.assign(n, a(n, e.target, { nodes: {
+				...t.nodes,
+				[e.nodeId]: e.node
+			} }));
+			break;
+		}
+		case "graph.node.delete": {
+			let t = i(n, e.target);
+			t.nodes[e.nodeId] ?? r();
+			let s = /* @__PURE__ */ new Set([e.nodeId]), c = Object.fromEntries(Object.entries(t.nodes).flatMap(([e, t]) => s.has(e) ? [] : [[e, o(t, s)]]));
+			if (Object.assign(n, a(n, e.target, { nodes: c })), e.target.kind == "subflow") {
+				let t = n.subflows[e.target.id], r = Object.fromEntries(Object.entries(t.outputs).map(([e, t]) => [e, {
+					...t,
+					sources: t.sources.filter((e) => e.kind != "node" || !s.has(e.nodeId))
+				}]));
+				n.subflows = {
+					...n.subflows,
+					[e.target.id]: {
+						...t,
+						outputs: r
+					}
+				};
+			}
+			break;
+		}
+		case "graph.node.replace": {
+			let t = i(n, e.target);
+			(t.nodes[e.nodeId] == null || e.target.kind == "subflow" && !("inputs" in e.node)) && r(), Object.assign(n, a(n, e.target, { nodes: {
+				...t.nodes,
+				[e.nodeId]: e.node
+			} }));
+			break;
+		}
+		case "module.create":
+			s[e.moduleId] != null && r(), s[e.moduleId] = e.module;
+			break;
+		case "module.delete":
+			s[e.moduleId] ?? r(), delete s[e.moduleId];
+			break;
+		case "module.rename": {
+			let t = s[e.moduleId];
+			t ?? r(), s[e.moduleId] = {
+				...t,
+				name: e.name
+			};
+			break;
+		}
+		case "module.source.replace": {
+			let t = s[e.moduleId];
+			t ?? r(), s[e.moduleId] = {
+				...t,
+				imports: e.imports,
+				source: e.source
+			};
+			break;
+		}
+		case "subflow.create":
+			n.subflows[e.subflowId] != null && r(), n.subflows = {
+				...n.subflows,
+				[e.subflowId]: e.subflow
+			};
+			break;
+		case "subflow.definition.replace": {
+			let t = n.subflows[e.subflowId];
+			t ?? r(), n.subflows = {
+				...n.subflows,
+				[e.subflowId]: {
+					...e.definition,
+					graph: t.graph
+				}
+			};
+			break;
+		}
+		case "subflow.delete": {
+			n.subflows[e.subflowId] ?? r();
+			let t = { ...n.subflows };
+			delete t[e.subflowId], n.subflows = t;
+			break;
+		}
+		case "task.create":
+			n.tasks[e.taskId] != null && r(), n.tasks = {
+				...n.tasks,
+				[e.taskId]: e.task
+			};
+			break;
+		case "task.delete": {
+			n.tasks[e.taskId] ?? r();
+			let t = { ...n.tasks };
+			delete t[e.taskId], n.tasks = t;
+			break;
+		}
+		case "task.replace": n.tasks[e.taskId] ?? r(), n.tasks = {
+			...n.tasks,
+			[e.taskId]: e.task
+		};
+	}
+	return {
+		document: n,
+		modelVersion: e.modelVersion,
+		modules: s
+	};
+}
+//#endregion
+export { n as ProjectChangeError, s as applyProjectChanges, t as resourceNameIssue, e as resourceNameMaxLength };

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

@@ -0,0 +1,12 @@
+export type ProjectChangeEvent = {
+    readonly kind: 'draft.changed';
+    readonly projectId: string;
+    readonly revisionId: string;
+    readonly version: 1;
+} | {
+    readonly flowId: string;
+    readonly kind: 'run.created';
+    readonly projectId: string;
+    readonly runId: string;
+    readonly version: 1;
+};

package/dist/browser/rolldown-runtime-CEFd7nDs.js

@@ -0,0 +1,30 @@
+//#region \0rolldown/runtime.js
+var e = Object.create, t = Object.defineProperty, n = Object.getOwnPropertyDescriptor, r = Object.getOwnPropertyNames, i = Object.getPrototypeOf, a = Object.prototype.hasOwnProperty, o = (e, t, n) => () => {
+	if (n) throw n[0];
+	try {
+		return e && (t = e(e = 0)), t;
+	} catch (e) {
+		throw n = [e], e;
+	}
+}, s = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t.exports), c = (e, n) => {
+	let r = {};
+	for (var i in e) t(r, i, {
+		get: e[i],
+		enumerable: !0
+	});
+	return n || t(r, Symbol.toStringTag, { value: "Module" }), r;
+}, l = (e, i, o, s) => {
+	if (i && typeof i == "object" || typeof i == "function") for (var c = r(i), l = 0, u = c.length, d; l < u; l++) d = c[l], !a.call(e, d) && d !== o && t(e, d, {
+		get: ((e) => i[e]).bind(null, d),
+		enumerable: !(s = n(i, d)) || s.enumerable
+	});
+	return e;
+}, u = (n, r, o) => (o = n == null ? {} : e(i(n)), l(r || !n || !n.__esModule || !a.call(n, "default") ? t(o, "default", {
+	value: n,
+	enumerable: !0
+}) : o, n)), d = (e) => a.call(e, "module.exports") ? e["module.exports"] : l(t({}, "__esModule", { value: !0 }), e), f = /* @__PURE__ */ ((e) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(e, { get: (e, t) => (typeof require < "u" ? require : e)[t] }) : e)(function(e) {
+	if (typeof require < "u") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + e + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+export { d as a, f as i, o as n, u as o, c as r, s as t };

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

@@ -0,0 +1,28 @@
+import type { ProjectChangeEvent } from './project-notifications.js';
+export type { ProjectChangeEvent } from './project-notifications.js';
+export type WorkbenchLanguage = 'en' | 'zh-CN';
+export type WorkbenchTheme = 'dark' | 'light';
+export type WorkbenchView = 'design' | 'publications' | 'runs';
+export interface WorkbenchNotification {
+    readonly kind: 'error' | 'success';
+    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>;
+    subscribeProject(projectId: string, listener: (event?: ProjectChangeEvent) => void): () => void;
+}
+export interface WorkbenchLocation {
+    readonly flowId?: string;
+    readonly projectId?: string;
+    readonly view: WorkbenchView;
+}
+export interface WorkbenchNavigationOptions {
+    readonly replace: boolean;
+}
+export interface WorkbenchPreferences {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}