@oomol-lab/open-flow 0.1.0-alpha.6 → 0.1.0-alpha.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -10,33 +10,36 @@ function t(e) {
10
10
  }
11
11
  if (!/^[\p{L}\p{N}](?:[\p{L}\p{N} _-]*[\p{L}\p{N}])?$/u.test(t)) return "specialCharacter";
12
12
  }
13
- var n = class extends Error {};
14
- function r() {
15
- throw new n();
13
+ function n(e) {
14
+ return Object.fromEntries(e.map((e) => [e.handle, e]));
16
15
  }
17
- function i(e, t) {
16
+ var r = class extends Error {};
17
+ function i() {
18
+ throw new r();
19
+ }
20
+ function a(e, t) {
18
21
  if (t.kind == "flow") return e.graph;
19
22
  let n = e.subflows[t.id];
20
- return n ?? r(), n.graph;
23
+ return n ?? i(), n.graph;
21
24
  }
22
- function a(e, t, n) {
25
+ function o(e, t, n) {
23
26
  if (t.kind == "flow") return {
24
27
  ...e,
25
28
  graph: n
26
29
  };
27
- let i = e.subflows[t.id];
28
- return i ?? r(), {
30
+ let r = e.subflows[t.id];
31
+ return r ?? i(), {
29
32
  ...e,
30
33
  subflows: {
31
34
  ...e.subflows,
32
35
  [t.id]: {
33
- ...i,
36
+ ...r,
34
37
  graph: n
35
38
  }
36
39
  }
37
40
  };
38
41
  }
39
- function o(e, t) {
42
+ function s(e, t) {
40
43
  if (!("inputs" in e)) return e;
41
44
  let n = { ...e.inputs };
42
45
  for (let [e, r] of Object.entries(n)) {
@@ -52,126 +55,126 @@ function o(e, t) {
52
55
  inputs: n
53
56
  };
54
57
  }
55
- function s(e, t) {
56
- let n = { ...e.document }, s = { ...e.modules };
58
+ function c(e, t) {
59
+ let n = { ...e.document }, r = { ...e.modules };
57
60
  for (let e of t) switch (e.kind) {
58
61
  case "binding.create":
59
- n.bindings[e.bindingId] != null && r(), n.bindings = {
62
+ n.bindings[e.bindingId] != null && i(), n.bindings = {
60
63
  ...n.bindings,
61
64
  [e.bindingId]: e.binding
62
65
  };
63
66
  break;
64
67
  case "binding.replace":
65
- n.bindings[e.bindingId] ?? r(), n.bindings = {
68
+ n.bindings[e.bindingId] ?? i(), n.bindings = {
66
69
  ...n.bindings,
67
70
  [e.bindingId]: e.binding
68
71
  };
69
72
  break;
70
73
  case "binding.delete": {
71
- n.bindings[e.bindingId] ?? r();
74
+ n.bindings[e.bindingId] ?? i();
72
75
  let t = { ...n.bindings };
73
76
  delete t[e.bindingId], n.bindings = t;
74
77
  break;
75
78
  }
76
79
  case "graph.edge.connect": {
77
- let t = i(n, e.target);
78
- t.nodes[e.edge.source] ?? r();
79
- let o = t.nodes[e.edge.target];
80
- (o == null || !("inputs" in o)) && r();
81
- let s = o.inputs[e.edge.targetHandle], c = {
80
+ let t = a(n, e.target);
81
+ t.nodes[e.edge.source] ?? i();
82
+ let r = t.nodes[e.edge.target];
83
+ (r == null || !("inputs" in r)) && i();
84
+ let s = r.inputs[e.edge.targetHandle], c = {
82
85
  kind: "node",
83
86
  nodeId: e.edge.source,
84
87
  output: e.edge.sourceHandle
85
88
  }, l = s?.kind == "sources" ? s.sources : [];
86
- l.some((e) => e.kind == "node" && e.nodeId == c.nodeId && e.output == c.output) && r();
89
+ l.some((e) => e.kind == "node" && e.nodeId == c.nodeId && e.output == c.output) && i();
87
90
  let u = {
88
- ...o,
91
+ ...r,
89
92
  inputs: {
90
- ...o.inputs,
93
+ ...r.inputs,
91
94
  [e.edge.targetHandle]: {
92
95
  kind: "sources",
93
96
  sources: [...l, c]
94
97
  }
95
98
  }
96
99
  };
97
- Object.assign(n, a(n, e.target, { nodes: {
100
+ Object.assign(n, o(n, e.target, { nodes: {
98
101
  ...t.nodes,
99
102
  [e.edge.target]: u
100
103
  } }));
101
104
  break;
102
105
  }
103
106
  case "graph.edge.disconnect": {
104
- let t = i(n, e.target), o = t.nodes[e.edge.target];
105
- (o == null || !("inputs" in o)) && r();
106
- let s = o.inputs[e.edge.targetHandle];
107
- s?.kind != "sources" && r();
107
+ let t = a(n, e.target), r = t.nodes[e.edge.target];
108
+ (r == null || !("inputs" in r)) && i();
109
+ let s = r.inputs[e.edge.targetHandle];
110
+ s?.kind != "sources" && i();
108
111
  let c = s.sources.filter((t) => t.kind != "node" || t.nodeId != e.edge.source || t.output != e.edge.sourceHandle);
109
- c.length == s.sources.length && r();
110
- let l = { ...o.inputs };
112
+ c.length == s.sources.length && i();
113
+ let l = { ...r.inputs };
111
114
  c.length == 0 ? delete l[e.edge.targetHandle] : l[e.edge.targetHandle] = {
112
115
  kind: "sources",
113
116
  sources: c
114
- }, Object.assign(n, a(n, e.target, { nodes: {
117
+ }, Object.assign(n, o(n, e.target, { nodes: {
115
118
  ...t.nodes,
116
119
  [e.edge.target]: {
117
- ...o,
120
+ ...r,
118
121
  inputs: l
119
122
  }
120
123
  } }));
121
124
  break;
122
125
  }
123
126
  case "graph.node.create": {
124
- let t = i(n, e.target);
125
- (t.nodes[e.nodeId] != null || e.target.kind == "subflow" && !("inputs" in e.node)) && r(), Object.assign(n, a(n, e.target, { nodes: {
127
+ let t = a(n, e.target);
128
+ (t.nodes[e.nodeId] != null || e.target.kind == "subflow" && !("inputs" in e.node)) && i(), Object.assign(n, o(n, e.target, { nodes: {
126
129
  ...t.nodes,
127
130
  [e.nodeId]: e.node
128
131
  } }));
129
132
  break;
130
133
  }
131
134
  case "graph.node.delete": {
132
- let t = i(n, e.target);
133
- t.nodes[e.nodeId] ?? r();
134
- let s = /* @__PURE__ */ new Set([e.nodeId]), c = Object.fromEntries(Object.entries(t.nodes).flatMap(([e, t]) => s.has(e) ? [] : [[e, o(t, s)]]));
135
- if (Object.assign(n, a(n, e.target, { nodes: c })), e.target.kind == "subflow") {
136
- let t = n.subflows[e.target.id], r = Object.fromEntries(Object.entries(t.outputs).map(([e, t]) => [e, {
137
- ...t,
138
- sources: t.sources.filter((e) => e.kind != "node" || !s.has(e.nodeId))
139
- }]));
135
+ let t = a(n, e.target);
136
+ t.nodes[e.nodeId] ?? i();
137
+ let r = /* @__PURE__ */ new Set([e.nodeId]), c = Object.fromEntries(Object.entries(t.nodes).flatMap(([e, t]) => r.has(e) ? [] : [[e, s(t, r)]]));
138
+ if (Object.assign(n, o(n, e.target, { nodes: c })), e.target.kind == "subflow") {
139
+ let t = n.subflows[e.target.id], i = t.outputs.map((e) => ({
140
+ ...e,
141
+ sources: e.sources.filter((e) => e.kind != "node" || !r.has(e.nodeId))
142
+ }));
140
143
  n.subflows = {
141
144
  ...n.subflows,
142
145
  [e.target.id]: {
143
146
  ...t,
144
- outputs: r
147
+ outputs: i
145
148
  }
146
149
  };
147
150
  }
148
151
  break;
149
152
  }
150
153
  case "graph.node.replace": {
151
- let t = i(n, e.target);
152
- (t.nodes[e.nodeId] == null || e.target.kind == "subflow" && !("inputs" in e.node)) && r(), Object.assign(n, a(n, e.target, { nodes: {
154
+ let t = a(n, e.target);
155
+ (t.nodes[e.nodeId] == null || e.target.kind == "subflow" && !("inputs" in e.node)) && i(), Object.assign(n, o(n, e.target, { nodes: {
153
156
  ...t.nodes,
154
157
  [e.nodeId]: e.node
155
158
  } }));
156
159
  break;
157
160
  }
158
161
  case "module.create":
159
- s[e.moduleId] != null && r(), s[e.moduleId] = e.module;
162
+ r[e.moduleId] != null && i(), r[e.moduleId] = e.module;
160
163
  break;
161
164
  case "module.delete":
162
- s[e.moduleId] ?? r(), delete s[e.moduleId];
165
+ r[e.moduleId] ?? i(), delete r[e.moduleId];
163
166
  break;
164
167
  case "module.rename": {
165
- let t = s[e.moduleId];
166
- t ?? r(), s[e.moduleId] = {
168
+ let t = r[e.moduleId];
169
+ t ?? i(), r[e.moduleId] = {
167
170
  ...t,
168
171
  name: e.name
169
172
  };
170
173
  break;
171
174
  }
172
175
  case "module.source.replace": {
173
- let t = s[e.moduleId];
174
- t ?? r(), s[e.moduleId] = {
176
+ let t = r[e.moduleId];
177
+ t ?? i(), r[e.moduleId] = {
175
178
  ...t,
176
179
  imports: e.imports,
177
180
  source: e.source
@@ -179,14 +182,14 @@ function s(e, t) {
179
182
  break;
180
183
  }
181
184
  case "subflow.create":
182
- n.subflows[e.subflowId] != null && r(), n.subflows = {
185
+ n.subflows[e.subflowId] != null && i(), n.subflows = {
183
186
  ...n.subflows,
184
187
  [e.subflowId]: e.subflow
185
188
  };
186
189
  break;
187
190
  case "subflow.definition.replace": {
188
191
  let t = n.subflows[e.subflowId];
189
- t ?? r(), n.subflows = {
192
+ t ?? i(), n.subflows = {
190
193
  ...n.subflows,
191
194
  [e.subflowId]: {
192
195
  ...e.definition,
@@ -196,24 +199,24 @@ function s(e, t) {
196
199
  break;
197
200
  }
198
201
  case "subflow.delete": {
199
- n.subflows[e.subflowId] ?? r();
202
+ n.subflows[e.subflowId] ?? i();
200
203
  let t = { ...n.subflows };
201
204
  delete t[e.subflowId], n.subflows = t;
202
205
  break;
203
206
  }
204
207
  case "task.create":
205
- n.tasks[e.taskId] != null && r(), n.tasks = {
208
+ n.tasks[e.taskId] != null && i(), n.tasks = {
206
209
  ...n.tasks,
207
210
  [e.taskId]: e.task
208
211
  };
209
212
  break;
210
213
  case "task.delete": {
211
- n.tasks[e.taskId] ?? r();
214
+ n.tasks[e.taskId] ?? i();
212
215
  let t = { ...n.tasks };
213
216
  delete t[e.taskId], n.tasks = t;
214
217
  break;
215
218
  }
216
- case "task.replace": n.tasks[e.taskId] ?? r(), n.tasks = {
219
+ case "task.replace": n.tasks[e.taskId] ?? i(), n.tasks = {
217
220
  ...n.tasks,
218
221
  [e.taskId]: e.task
219
222
  };
@@ -221,8 +224,8 @@ function s(e, t) {
221
224
  return {
222
225
  document: n,
223
226
  modelVersion: e.modelVersion,
224
- modules: s
227
+ modules: r
225
228
  };
226
229
  }
227
230
  //#endregion
228
- export { n as FlowChangeError, s as applyFlowChanges, t as resourceNameIssue, e as resourceNameMaxLength };
231
+ export { r as FlowChangeError, c as applyFlowChanges, n as portsByHandle, t as resourceNameIssue, e as resourceNameMaxLength };