@picked/client 0.0.98-next.1 → 0.0.98-next.3
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.
- package/dist/.tsbuildinfo +1 -1
- package/dist/{api-BgPyneD7.cjs → api-DKvG5BpW.cjs} +1 -1
- package/dist/{api-CONFKApU.js → api-Du1CXHwf.js} +1 -1
- package/dist/cjs/index.js +2 -2
- package/dist/cjs/plugins/dynamic-experiences/index.js +1 -1
- package/dist/cjs/server/index.js +1 -1
- package/dist/docs/how-to/call-an-external-api-from-a-workflow.md +26 -3
- package/dist/docs/how-to/register-an-action-handler.md +19 -1
- package/dist/docs/how-to/wait-for-an-action-response.md +182 -0
- package/dist/docs/reference/dashboard/actions.mdx +5 -2
- package/dist/docs/reference/dashboard/external-apis.md +61 -29
- package/dist/docs/reference/dashboard/workflow-runs.md +30 -5
- package/dist/docs/reference/dashboard/workflow-test-runs.md +9 -5
- package/dist/docs/reference/delivery-api/workspace-schema.md +3 -0
- package/dist/docs/reference/sdk/actions.md +127 -3
- package/dist/docs/reference/sdk/type-generation.md +8 -0
- package/dist/esm/index.js +514 -328
- package/dist/esm/plugins/dynamic-experiences/index.js +4 -4
- package/dist/esm/server/index.js +3 -3
- package/dist/{experience-instance-DptBuxBJ.js → experience-instance-4KUBH8Gb.js} +278 -220
- package/dist/experience-instance-C9WV52iQ.cjs +1 -0
- package/dist/plugin-CsE8tmaX.cjs +1 -0
- package/dist/{plugin-BZg0v-pk.js → plugin-CttEcyFL.js} +96 -69
- package/dist/{preview-unavailable-zegsv152.js → preview-unavailable-ByX1cyKS.js} +1 -1
- package/dist/{preview-unavailable-BC8sZ_nk.cjs → preview-unavailable-DlWDUdpa.cjs} +1 -1
- package/dist/{provider-reK0A8tr.cjs → provider-B1TabtRC.cjs} +1 -1
- package/dist/{provider-DHsKj_FK.js → provider-DdRIjrTz.js} +1 -1
- package/dist/types/entities/action/action.d.ts +94 -23
- package/dist/types/entities/action/action.d.ts.map +1 -1
- package/dist/types/entities/experience-instance/experience-instance.d.ts.map +1 -1
- package/dist/types/index.d.ts +1 -1
- package/dist/types/index.d.ts.map +1 -1
- package/dist/types/lifecycle/rules-logic.d.ts.map +1 -1
- package/dist/types/picked.d.ts +26 -6
- package/dist/types/picked.d.ts.map +1 -1
- package/dist/types/plugins/dynamic-experiences/index.d.ts +1 -0
- package/dist/types/plugins/dynamic-experiences/index.d.ts.map +1 -1
- package/dist/types/plugins/dynamic-experiences/plugin.d.ts.map +1 -1
- package/dist/types/schema-registry.d.ts +10 -0
- package/dist/types/schema-registry.d.ts.map +1 -1
- package/package.json +4 -4
- package/dist/experience-instance-CQvQHCNe.cjs +0 -1
- package/dist/plugin-CuYWwfVi.cjs +0 -1
|
@@ -10,13 +10,13 @@ function m(e) {
|
|
|
10
10
|
function h(e) {
|
|
11
11
|
return e.type === "step";
|
|
12
12
|
}
|
|
13
|
-
function
|
|
13
|
+
function g(e) {
|
|
14
14
|
return e.type === "experience";
|
|
15
15
|
}
|
|
16
|
-
function
|
|
16
|
+
function _(e) {
|
|
17
17
|
return e.type === "origin";
|
|
18
18
|
}
|
|
19
|
-
function
|
|
19
|
+
function ee(e) {
|
|
20
20
|
return e.type === "action";
|
|
21
21
|
}
|
|
22
22
|
//#endregion
|
|
@@ -43,7 +43,7 @@ var v = [], y = (e, t) => {
|
|
|
43
43
|
e !== void 0 && r.push(e);
|
|
44
44
|
}
|
|
45
45
|
return r;
|
|
46
|
-
},
|
|
46
|
+
}, te = (e, t) => {
|
|
47
47
|
let n = /* @__PURE__ */ new Map();
|
|
48
48
|
t.forEach((e, t) => {
|
|
49
49
|
n.set(e, t);
|
|
@@ -64,7 +64,7 @@ var v = [], y = (e, t) => {
|
|
|
64
64
|
let s = e.nodeById.get(t)?.type === "origin";
|
|
65
65
|
r.isOrigin.push(s), s && r.origins.push(i);
|
|
66
66
|
}), r;
|
|
67
|
-
},
|
|
67
|
+
}, D = (e, t, n) => {
|
|
68
68
|
let r = w(n, S), i = [...e];
|
|
69
69
|
for (let t of e) r[t] = 0;
|
|
70
70
|
let a = 0, o = 0;
|
|
@@ -79,28 +79,28 @@ var v = [], y = (e, t) => {
|
|
|
79
79
|
values: r,
|
|
80
80
|
visits: a
|
|
81
81
|
};
|
|
82
|
-
},
|
|
82
|
+
}, O = (e, t) => {
|
|
83
83
|
e.discoveryOf[t] = e.counter, e.lowLinkOf[t] = e.counter, e.counter += 1, e.stack.push(t), e.onStack[t] = !0, e.frames.push({
|
|
84
84
|
node: t,
|
|
85
85
|
edge: 0
|
|
86
86
|
}), e.visits += 1;
|
|
87
|
-
},
|
|
87
|
+
}, ne = (e, t) => {
|
|
88
88
|
let n = (e.successors[t.node] ?? [])[t.edge];
|
|
89
89
|
if (t.edge += 1, n !== void 0) {
|
|
90
90
|
if (e.discoveryOf[n] === S) {
|
|
91
|
-
|
|
91
|
+
O(e, n);
|
|
92
92
|
return;
|
|
93
93
|
}
|
|
94
94
|
e.onStack[n] && (e.lowLinkOf[t.node] = Math.min(e.lowLinkOf[t.node] ?? 0, e.discoveryOf[n] ?? 0));
|
|
95
95
|
}
|
|
96
|
-
},
|
|
96
|
+
}, k = (e, t) => {
|
|
97
97
|
e.frames.pop(), e.visits += 1;
|
|
98
98
|
let n = e.frames.at(-1);
|
|
99
99
|
if (n && (e.lowLinkOf[n.node] = Math.min(e.lowLinkOf[n.node] ?? 0, e.lowLinkOf[t.node] ?? 0)), e.lowLinkOf[t.node] !== e.discoveryOf[t.node]) return;
|
|
100
100
|
let r = [], i = e.stack.pop();
|
|
101
101
|
for (; i !== void 0 && (e.onStack[i] = !1, e.componentOf[i] = e.members.length, r.push(i), i !== t.node);) i = e.stack.pop();
|
|
102
102
|
e.members.push(r);
|
|
103
|
-
},
|
|
103
|
+
}, re = (e, t) => {
|
|
104
104
|
let n = {
|
|
105
105
|
successors: e,
|
|
106
106
|
discoveryOf: w(t, S),
|
|
@@ -113,17 +113,17 @@ var v = [], y = (e, t) => {
|
|
|
113
113
|
counter: 0,
|
|
114
114
|
visits: 0
|
|
115
115
|
};
|
|
116
|
-
for (let r = 0; r < t; r += 1) if (n.discoveryOf[r] === S) for (
|
|
116
|
+
for (let r = 0; r < t; r += 1) if (n.discoveryOf[r] === S) for (O(n, r); n.frames.length > 0;) {
|
|
117
117
|
let t = n.frames.at(-1);
|
|
118
118
|
if (!t) break;
|
|
119
|
-
t.edge < (e[t.node] ?? []).length ?
|
|
119
|
+
t.edge < (e[t.node] ?? []).length ? ne(n, t) : k(n, t);
|
|
120
120
|
}
|
|
121
121
|
return {
|
|
122
122
|
componentOf: n.componentOf,
|
|
123
123
|
members: n.members,
|
|
124
124
|
visits: n.visits
|
|
125
125
|
};
|
|
126
|
-
},
|
|
126
|
+
}, A = (e, t, n) => {
|
|
127
127
|
let r = C;
|
|
128
128
|
for (let i of e.adjacency[t] ?? []) {
|
|
129
129
|
let t = e.components.componentOf[i] ?? S;
|
|
@@ -132,17 +132,17 @@ var v = [], y = (e, t) => {
|
|
|
132
132
|
a !== C && (r = Math.max(r, a + 1));
|
|
133
133
|
}
|
|
134
134
|
return r;
|
|
135
|
-
},
|
|
135
|
+
}, j = (e, t) => {
|
|
136
136
|
let n = C;
|
|
137
137
|
for (let r of e.components.members[t] ?? []) {
|
|
138
138
|
if (e.isTerminus[r]) {
|
|
139
139
|
n = Math.max(n, 0);
|
|
140
140
|
continue;
|
|
141
141
|
}
|
|
142
|
-
n = Math.max(n,
|
|
142
|
+
n = Math.max(n, A(e, r, t));
|
|
143
143
|
}
|
|
144
144
|
return n;
|
|
145
|
-
},
|
|
145
|
+
}, M = (e, t, n, r) => {
|
|
146
146
|
let i = n.members.length, a = {
|
|
147
147
|
adjacency: e,
|
|
148
148
|
isTerminus: t,
|
|
@@ -152,7 +152,7 @@ var v = [], y = (e, t) => {
|
|
|
152
152
|
for (let e = 0; e < i; e += 1) {
|
|
153
153
|
let t = r ? i - 1 - e : e, s = (n.members[t] ?? []).length;
|
|
154
154
|
o += s;
|
|
155
|
-
let c =
|
|
155
|
+
let c = j(a, t);
|
|
156
156
|
a.perComponent[t] = c === C ? C : c + s - 1;
|
|
157
157
|
}
|
|
158
158
|
return {
|
|
@@ -163,54 +163,54 @@ var v = [], y = (e, t) => {
|
|
|
163
163
|
}),
|
|
164
164
|
visits: o
|
|
165
165
|
};
|
|
166
|
-
},
|
|
166
|
+
}, N = (e, t, n) => {
|
|
167
167
|
let r = /* @__PURE__ */ new Map();
|
|
168
168
|
return e.forEach((e, i) => {
|
|
169
169
|
let a = t.values[i] ?? S, o = n.values[i] ?? S;
|
|
170
170
|
r.set(e, a === S ? [S, S] : [a, o]);
|
|
171
171
|
}), r;
|
|
172
|
-
},
|
|
173
|
-
let n = y(e, t), r = [...n.nodeById.keys()], i = r.length, a =
|
|
172
|
+
}, ie = (e, t) => {
|
|
173
|
+
let n = y(e, t), r = [...n.nodeById.keys()], i = r.length, a = te(n, r), o = re(a.successors, i), s = D(a.leaves, a.predecessors, i), c = M(a.successors, a.isLeaf, o, !1), l = D(a.origins, a.successors, i), u = M(a.predecessors, a.isOrigin, o, !0);
|
|
174
174
|
return {
|
|
175
175
|
...n,
|
|
176
|
-
stepsToLeaf:
|
|
177
|
-
stepsToOrigin:
|
|
176
|
+
stepsToLeaf: N(r, s, c),
|
|
177
|
+
stepsToOrigin: N(r, l, u),
|
|
178
178
|
nodeVisits: o.visits + s.visits + c.visits + l.visits + u.visits
|
|
179
179
|
};
|
|
180
|
-
},
|
|
180
|
+
}, P = (e, t, n) => {
|
|
181
181
|
let r = Infinity, i = C;
|
|
182
182
|
for (let a of t) {
|
|
183
183
|
let t = e.get(a[n]);
|
|
184
184
|
!t || t[0] === S || (r = Math.min(r, t[0] + 1), i = Math.max(i, t[1] + 1));
|
|
185
185
|
}
|
|
186
186
|
return r === Infinity ? [S, S] : [r, i];
|
|
187
|
-
},
|
|
187
|
+
}, ae = (e, t) => {
|
|
188
188
|
let n = e.stepsToLeaf.get(t.id);
|
|
189
189
|
if (n) return [n[0], n[1]];
|
|
190
190
|
let r = b(e, t.id);
|
|
191
|
-
return r.length === 0 ? [0, 0] :
|
|
192
|
-
},
|
|
191
|
+
return r.length === 0 ? [0, 0] : P(e.stepsToLeaf, r, "destinationNodeId");
|
|
192
|
+
}, oe = (e, t) => {
|
|
193
193
|
let n = e.stepsToOrigin.get(t.id);
|
|
194
|
-
return n ? [n[0], n[1]] : t.type === "origin" ? [0, 0] :
|
|
195
|
-
},
|
|
196
|
-
function
|
|
194
|
+
return n ? [n[0], n[1]] : t.type === "origin" ? [0, 0] : P(e.stepsToOrigin, x(e, t.id), "sourceNodeId");
|
|
195
|
+
}, F = "conditions.", I = s("condition-results");
|
|
196
|
+
function L(e) {
|
|
197
197
|
return typeof e == "object" && !!e && !Array.isArray(e);
|
|
198
198
|
}
|
|
199
|
-
function
|
|
199
|
+
function R(e) {
|
|
200
200
|
if (e === void 0) return null;
|
|
201
|
-
if (Array.isArray(e)) return e.map((e) =>
|
|
202
|
-
if (
|
|
201
|
+
if (Array.isArray(e)) return e.map((e) => R(e));
|
|
202
|
+
if (L(e)) {
|
|
203
203
|
let t = Object.keys(e).sort((e, t) => e.localeCompare(t)), n = {};
|
|
204
|
-
for (let r of t) n[r] =
|
|
204
|
+
for (let r of t) n[r] = R(e[r]);
|
|
205
205
|
return n;
|
|
206
206
|
}
|
|
207
207
|
return e;
|
|
208
208
|
}
|
|
209
|
-
function
|
|
210
|
-
return JSON.stringify(
|
|
209
|
+
function se(e) {
|
|
210
|
+
return JSON.stringify(R(e));
|
|
211
211
|
}
|
|
212
|
-
var
|
|
213
|
-
let e =
|
|
212
|
+
var ce = f(() => {
|
|
213
|
+
let e = I.store({}), t = o(e, {
|
|
214
214
|
set(e, t) {
|
|
215
215
|
return e[t.hash] === t.result ? e : {
|
|
216
216
|
...e,
|
|
@@ -247,118 +247,118 @@ var oe = f(() => {
|
|
|
247
247
|
reset: i
|
|
248
248
|
};
|
|
249
249
|
});
|
|
250
|
-
function
|
|
251
|
-
return p(
|
|
250
|
+
function z() {
|
|
251
|
+
return p(ce);
|
|
252
252
|
}
|
|
253
|
-
async function
|
|
253
|
+
async function B(n, r, i) {
|
|
254
254
|
return r == null ? !0 : typeof r == "boolean" ? r : !e(r) || await t(n, r, i) === !0;
|
|
255
255
|
}
|
|
256
|
-
function
|
|
256
|
+
function V(e) {
|
|
257
257
|
if (typeof e == "string") return e;
|
|
258
258
|
if (Array.isArray(e) && typeof e[0] == "string") return e[0];
|
|
259
259
|
}
|
|
260
|
-
function
|
|
261
|
-
if (Array.isArray(e)) return e.some(
|
|
262
|
-
if (
|
|
263
|
-
let t =
|
|
264
|
-
return t !== void 0 && (t === "actions" || t.startsWith("actions.")) ? !0 : Object.values(e).some(
|
|
260
|
+
function H(e) {
|
|
261
|
+
if (Array.isArray(e)) return e.some(H);
|
|
262
|
+
if (L(e)) {
|
|
263
|
+
let t = V(e.var);
|
|
264
|
+
return t !== void 0 && (t === "actions" || t.startsWith("actions.")) ? !0 : Object.values(e).some(H);
|
|
265
265
|
}
|
|
266
266
|
return !1;
|
|
267
267
|
}
|
|
268
|
-
function
|
|
269
|
-
if (Array.isArray(e)) return e.flatMap(
|
|
270
|
-
if (
|
|
271
|
-
let t =
|
|
272
|
-
return [...t !== void 0 && t.startsWith(
|
|
268
|
+
function U(e) {
|
|
269
|
+
if (Array.isArray(e)) return e.flatMap(U);
|
|
270
|
+
if (L(e)) {
|
|
271
|
+
let t = V(e.var);
|
|
272
|
+
return [...t !== void 0 && t.startsWith(F) ? [t.slice(11)] : [], ...Object.values(e).flatMap(U)];
|
|
273
273
|
}
|
|
274
274
|
return [];
|
|
275
275
|
}
|
|
276
|
-
function
|
|
277
|
-
if (
|
|
278
|
-
for (let r of
|
|
276
|
+
function W(e, t, n = /* @__PURE__ */ new Set()) {
|
|
277
|
+
if (H(e)) return !0;
|
|
278
|
+
for (let r of U(e)) {
|
|
279
279
|
if (n.has(r)) continue;
|
|
280
280
|
n.add(r);
|
|
281
281
|
let e = t[r];
|
|
282
|
-
if (e !== void 0 &&
|
|
282
|
+
if (e !== void 0 && W(e.logic, t, n)) return !0;
|
|
283
283
|
}
|
|
284
284
|
return !1;
|
|
285
285
|
}
|
|
286
|
-
async function
|
|
286
|
+
async function G(e, t, n) {
|
|
287
287
|
let r = {};
|
|
288
288
|
for (let t of e.conditions.listStore.getState()) r[t.key] = t;
|
|
289
|
-
let i =
|
|
289
|
+
let i = W(t, r), a = se(t);
|
|
290
290
|
if (!i) {
|
|
291
291
|
let t = e.conditionResults.peek(a);
|
|
292
292
|
if (t !== void 0) return t;
|
|
293
293
|
}
|
|
294
|
-
let o = await
|
|
294
|
+
let o = await B(e, t, n?.context);
|
|
295
295
|
return i || e.conditionResults.set({
|
|
296
296
|
hash: a,
|
|
297
297
|
result: o
|
|
298
298
|
}), o;
|
|
299
299
|
}
|
|
300
|
-
async function
|
|
300
|
+
async function le(e, t, n) {
|
|
301
301
|
let r = n?.context, i = [
|
|
302
302
|
n?.precondition,
|
|
303
303
|
n?.condition,
|
|
304
304
|
t.condition
|
|
305
305
|
];
|
|
306
|
-
for (let t of i) if (!await
|
|
306
|
+
for (let t of i) if (!await G(e, t, { context: r })) return !1;
|
|
307
307
|
return !0;
|
|
308
308
|
}
|
|
309
309
|
//#endregion
|
|
310
310
|
//#region src/utils/node-tree/next-reachable-step-nodes.ts
|
|
311
|
-
var
|
|
311
|
+
var K = (e, t, n, r) => r.has(t.id) ? [] : (r.add(t.id), h(t) && !n ? [t] : b(e, t.id).flatMap((t) => {
|
|
312
312
|
let n = e.nodeById.get(t.destinationNodeId);
|
|
313
|
-
return n ?
|
|
314
|
-
})),
|
|
315
|
-
if (!e) return
|
|
313
|
+
return n ? K(e, n, !1, r) : [];
|
|
314
|
+
})), ue = (e, t) => K(e, t, !0, /* @__PURE__ */ new Set()), de = (e) => e.find((e) => e.type === "origin") || null, q = (e, t, n) => {
|
|
315
|
+
if (!e) return de(t);
|
|
316
316
|
let r = n.find((t) => t.sourceNodeId === e.id);
|
|
317
317
|
return r && t.find((e) => e.id === r.destinationNodeId) || null;
|
|
318
318
|
};
|
|
319
319
|
//#endregion
|
|
320
320
|
//#region src/utils/node-tree/get-next-node-from-condition.ts
|
|
321
|
-
async function
|
|
321
|
+
async function fe(e, t, n, r) {
|
|
322
322
|
let i = e ? "true" : "false", a = r.find((e) => e.sourceHandle === i && e.sourceNodeId === t);
|
|
323
323
|
return n.find((e) => e.id === a?.destinationNodeId);
|
|
324
324
|
}
|
|
325
325
|
//#endregion
|
|
326
326
|
//#region src/utils/node-tree/get-next-node-from-action.ts
|
|
327
|
-
function
|
|
327
|
+
function pe(e, t, n, r) {
|
|
328
328
|
let i = r.filter((e) => e.sourceNodeId === t), a = e ? "true" : "false", o = i.find((e) => e.sourceHandle === a) ?? i.find((e) => e.sourceHandle == null);
|
|
329
329
|
return n.find((e) => e.id === o?.destinationNodeId);
|
|
330
330
|
}
|
|
331
331
|
//#endregion
|
|
332
332
|
//#region src/entities/experience-instance/experience-instance.ts
|
|
333
|
-
var
|
|
334
|
-
let b = l(), x = l(), S = l(), C = l(), w = l(), T = l(), E = l(),
|
|
333
|
+
var J = s("experience-instance"), Y = /* @__PURE__ */ new WeakMap(), me = f(({ client: r, experience: s, target: f, options: p, deferOpen: v, slotOpen: y }) => {
|
|
334
|
+
let b = l(), x = l(), S = l(), C = l(), w = l(), T = l(), E = l(), te = l(), D = l(), O = s.componentStore, ne = J.store("transitioning"), k = r.history.entriesStore.map((e) => e.filter((e) => e.experienceId === s.id)), re = k.map((e) => e.filter((e) => h(e.node))), A = k.map((e) => e.at(-1)?.node || null), j = J.store(null);
|
|
335
335
|
u({
|
|
336
336
|
clock: [
|
|
337
|
-
|
|
337
|
+
A,
|
|
338
338
|
r.steps.listStore,
|
|
339
339
|
T
|
|
340
340
|
],
|
|
341
341
|
source: {
|
|
342
342
|
steps: r.steps.listStore,
|
|
343
|
-
node:
|
|
343
|
+
node: A
|
|
344
344
|
},
|
|
345
345
|
filter: ({ node: e }) => e !== null && h(e),
|
|
346
346
|
fn: ({ steps: e, node: t }) => t && h(t) ? e.find((e) => e.id === t.stepId) ?? null : null,
|
|
347
|
-
target:
|
|
347
|
+
target: j
|
|
348
348
|
});
|
|
349
|
-
let
|
|
349
|
+
let M = a(r.steps.listStore, re, (e, t) => {
|
|
350
350
|
let n = t.at(-2);
|
|
351
351
|
if (!n || !h(n.node)) return null;
|
|
352
352
|
let r = n.node;
|
|
353
353
|
return e.find((e) => e.id === r.stepId) || null;
|
|
354
|
-
}),
|
|
354
|
+
}), N = a(s.nodeTreeStore, A, (e, t) => t ? ue(e, t) : []), ie = a(s.nodeTreeStore, A, (e, t) => t ? oe(e, t) : [-1, -1]), P = a(s.nodeTreeStore, A, (e, t) => t ? ae(e, t) : [-1, -1]), F = J.store(!v).on(te, (e, t) => t), I = J.store(!1), L = o(I, {
|
|
355
355
|
open: () => !0,
|
|
356
356
|
close: () => !1,
|
|
357
357
|
toggle: (e) => !e,
|
|
358
358
|
set: (e, t) => t
|
|
359
|
-
}),
|
|
359
|
+
}), R = c(async () => {
|
|
360
360
|
r.history.back({ experienceId: s.id });
|
|
361
|
-
}),
|
|
361
|
+
}), se = i({
|
|
362
362
|
source: s.treeStore,
|
|
363
363
|
effect: async (e, t) => {
|
|
364
364
|
let n = e.nodes.find((e) => h(e) && e.stepId === t);
|
|
@@ -367,7 +367,7 @@ var Z = s("experience-instance"), de = /* @__PURE__ */ new WeakMap(), fe = f(({
|
|
|
367
367
|
node: n
|
|
368
368
|
});
|
|
369
369
|
}
|
|
370
|
-
}),
|
|
370
|
+
}), ce = i({
|
|
371
371
|
source: s.treeStore,
|
|
372
372
|
effect: async (e, t) => {
|
|
373
373
|
let n = e.steps.find((e) => e.key === t);
|
|
@@ -378,84 +378,137 @@ var Z = s("experience-instance"), de = /* @__PURE__ */ new WeakMap(), fe = f(({
|
|
|
378
378
|
node: i
|
|
379
379
|
});
|
|
380
380
|
}
|
|
381
|
-
}),
|
|
382
|
-
source: j,
|
|
383
|
-
effect: (e) => {}
|
|
384
|
-
}), H = i({
|
|
381
|
+
}), z = c(() => void 0), B = i({
|
|
385
382
|
source: s.treeStore,
|
|
386
|
-
effect: async ({ nodes: e }) =>
|
|
387
|
-
}),
|
|
383
|
+
effect: async ({ nodes: e }) => de(e)
|
|
384
|
+
}), V = i({
|
|
388
385
|
source: s.treeStore,
|
|
389
386
|
effect: async ({ nodes: e, edges: t }, n) => {
|
|
390
|
-
if (
|
|
387
|
+
if (_(n)) return q(n, e, t);
|
|
391
388
|
}
|
|
392
|
-
}),
|
|
393
|
-
source:
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
389
|
+
}), H = i({
|
|
390
|
+
source: {
|
|
391
|
+
tree: s.treeStore,
|
|
392
|
+
history: k
|
|
393
|
+
},
|
|
394
|
+
effect: async ({ tree: e, history: n }, i) => {
|
|
395
|
+
let { nodes: a, edges: o, conditions: s } = e, c = n.at(-1), l = m(i) ? s.find((e) => e.id === i.conditionId)?.logic : void 0;
|
|
396
|
+
if (!m(i) || !l) return {
|
|
397
|
+
next: null,
|
|
398
|
+
startedFrom: c
|
|
399
|
+
};
|
|
400
|
+
try {
|
|
401
|
+
return {
|
|
402
|
+
next: await fe(!!await t(r, l), i.id, a, o) ?? null,
|
|
403
|
+
startedFrom: c
|
|
404
|
+
};
|
|
405
|
+
} catch {
|
|
406
|
+
return `${i.id}`, {
|
|
407
|
+
next: null,
|
|
408
|
+
startedFrom: c
|
|
409
|
+
};
|
|
410
|
+
}
|
|
398
411
|
}
|
|
399
|
-
}),
|
|
412
|
+
}), U = i({
|
|
400
413
|
source: {
|
|
401
414
|
tree: s.treeStore,
|
|
402
415
|
actions: r.actions.listStore,
|
|
403
|
-
snapshot: r.stateSnapshotStore
|
|
416
|
+
snapshot: r.stateSnapshotStore,
|
|
417
|
+
history: k
|
|
404
418
|
},
|
|
405
|
-
effect: async ({ tree: e, actions: t, snapshot: n },
|
|
406
|
-
let { nodes:
|
|
407
|
-
if (!
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
}
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
419
|
+
effect: async ({ tree: e, actions: t, snapshot: n, history: r }, i) => {
|
|
420
|
+
let { nodes: a, edges: o } = e, s = r.at(-1);
|
|
421
|
+
if (!ee(i)) return {
|
|
422
|
+
next: null,
|
|
423
|
+
startedFrom: s
|
|
424
|
+
};
|
|
425
|
+
let c = i.actionKey;
|
|
426
|
+
if (!c) return `${i.id}`, {
|
|
427
|
+
next: null,
|
|
428
|
+
startedFrom: s
|
|
429
|
+
};
|
|
430
|
+
let l = t.find((e) => e.key === c)?.action;
|
|
431
|
+
if (typeof l != "function") return `${c}`, {
|
|
432
|
+
next: pe(!1, i.id, a, o) ?? null,
|
|
433
|
+
startedFrom: s
|
|
434
|
+
};
|
|
435
|
+
let u = new AbortController(), d = k.watch((e) => {
|
|
436
|
+
e.at(-1) !== s && u.abort();
|
|
437
|
+
}), f = !0;
|
|
416
438
|
try {
|
|
417
|
-
`${
|
|
439
|
+
`${c}`, await l({
|
|
418
440
|
...n,
|
|
419
|
-
args: []
|
|
441
|
+
args: [],
|
|
442
|
+
signal: u.signal
|
|
420
443
|
}, { experience: $ });
|
|
421
444
|
} catch {
|
|
422
|
-
`${
|
|
445
|
+
u.signal.aborted || `${c}`, f = !1;
|
|
446
|
+
} finally {
|
|
447
|
+
d();
|
|
423
448
|
}
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
449
|
+
if (u.signal.aborted) return `${c}${i.id}`, {
|
|
450
|
+
next: null,
|
|
451
|
+
startedFrom: s
|
|
452
|
+
};
|
|
453
|
+
let p = pe(f, i.id, a, o);
|
|
454
|
+
if (!p) {
|
|
455
|
+
let e = o.some((e) => e.sourceNodeId === i.id) ? "no edge for its outcome" : "no outgoing edge";
|
|
456
|
+
return `${i.id}${e}`, {
|
|
457
|
+
next: null,
|
|
458
|
+
startedFrom: s
|
|
459
|
+
};
|
|
428
460
|
}
|
|
429
|
-
return `${
|
|
461
|
+
return `${c}${p.id}`, {
|
|
462
|
+
next: p,
|
|
463
|
+
startedFrom: s
|
|
464
|
+
};
|
|
430
465
|
}
|
|
431
|
-
}),
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
source:
|
|
435
|
-
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
466
|
+
}), W = l(), G = l(), le = J.store(null).on(W, (e, t) => t).on(G, (e, t) => e === t ? null : e);
|
|
467
|
+
u({
|
|
468
|
+
clock: [H, U],
|
|
469
|
+
source: k,
|
|
470
|
+
fn: (e) => e.at(-1) ?? null,
|
|
471
|
+
target: W
|
|
472
|
+
});
|
|
473
|
+
let K = l();
|
|
474
|
+
u({
|
|
475
|
+
clock: [H.doneData, U.doneData],
|
|
476
|
+
fn: (e) => e.startedFrom ?? null,
|
|
477
|
+
target: G
|
|
478
|
+
}), u({
|
|
479
|
+
clock: [H.doneData, U.doneData],
|
|
480
|
+
source: k,
|
|
481
|
+
fn: (e, t) => e.at(-1) === t.startedFrom ? t.next : null,
|
|
482
|
+
target: K
|
|
483
|
+
});
|
|
484
|
+
let me = a(le, k, (e, t) => e !== null && e === t.at(-1)), X = me.map((e) => !e), he = c((e) => {
|
|
485
|
+
g(e) && r.experiences.launch({ key: e.experienceKey });
|
|
486
|
+
}), Z = i({
|
|
487
|
+
source: [A, s.treeStore],
|
|
488
|
+
effect: async ([e, { nodes: t, edges: n }]) => q(e, t, n)
|
|
489
|
+
}), Q = i({
|
|
490
|
+
source: [A, s.treeStore],
|
|
491
|
+
effect: async ([e, { nodes: t, edges: n }]) => q(e, t, n)
|
|
492
|
+
}), ge = i({
|
|
493
|
+
source: F,
|
|
441
494
|
effect: (e, t) => {
|
|
442
495
|
e && r.history.push({
|
|
443
496
|
experienceId: s.id,
|
|
444
497
|
node: t
|
|
445
498
|
});
|
|
446
499
|
}
|
|
447
|
-
}),
|
|
500
|
+
}), _e = i({
|
|
448
501
|
source: s.configStore,
|
|
449
502
|
effect: async ({ initializeOpenLogic: n }) => p?.initialiseOpen === void 0 ? n == null ? y === "rendered" : e(n) ? !!await t(r, n) : n : p.initialiseOpen
|
|
450
|
-
}),
|
|
503
|
+
}), ve = a(O, r.frameworks.listStore, (e, t) => {
|
|
451
504
|
if (!e) return null;
|
|
452
505
|
let n = t.find((t) => t.name === e.component.frameworkName);
|
|
453
506
|
return n ? {
|
|
454
507
|
component: e,
|
|
455
508
|
framework: n
|
|
456
509
|
} : null;
|
|
457
|
-
}, { skipVoid: !1 }), $,
|
|
458
|
-
source:
|
|
510
|
+
}, { skipVoid: !1 }), $, ye = i({
|
|
511
|
+
source: ve,
|
|
459
512
|
effect: (e) => {
|
|
460
513
|
if (!e) return;
|
|
461
514
|
if (!f) {
|
|
@@ -475,169 +528,174 @@ var Z = s("experience-instance"), de = /* @__PURE__ */ new WeakMap(), fe = f(({
|
|
|
475
528
|
experienceName: s.name,
|
|
476
529
|
configStore: s.configStore,
|
|
477
530
|
target: f,
|
|
478
|
-
componentStore:
|
|
479
|
-
componentAndFrameworkStore:
|
|
480
|
-
stateStore:
|
|
481
|
-
isOpenStore:
|
|
482
|
-
open:
|
|
483
|
-
close:
|
|
484
|
-
toggleOpen:
|
|
485
|
-
setOpen:
|
|
531
|
+
componentStore: O,
|
|
532
|
+
componentAndFrameworkStore: ve,
|
|
533
|
+
stateStore: ne,
|
|
534
|
+
isOpenStore: I,
|
|
535
|
+
open: L.open,
|
|
536
|
+
close: L.close,
|
|
537
|
+
toggleOpen: L.toggle,
|
|
538
|
+
setOpen: L.set,
|
|
486
539
|
treeStore: s.treeStore,
|
|
487
|
-
currentNodeStore:
|
|
488
|
-
currentStepStore:
|
|
489
|
-
previousStepStore:
|
|
490
|
-
nextReachableStepNodesStore:
|
|
491
|
-
stepsToOriginStore:
|
|
492
|
-
stepsToLeafStore:
|
|
540
|
+
currentNodeStore: A,
|
|
541
|
+
currentStepStore: j,
|
|
542
|
+
previousStepStore: M,
|
|
543
|
+
nextReachableStepNodesStore: N,
|
|
544
|
+
stepsToOriginStore: ie,
|
|
545
|
+
stepsToLeafStore: P,
|
|
493
546
|
goToNextStep: x,
|
|
494
547
|
goToPreviousStep: S,
|
|
495
548
|
goToStepById: C,
|
|
496
549
|
goToStepByKey: w,
|
|
497
|
-
stepsHistoryStore:
|
|
498
|
-
mountFx:
|
|
550
|
+
stepsHistoryStore: re,
|
|
551
|
+
mountFx: ye
|
|
499
552
|
});
|
|
500
|
-
let
|
|
501
|
-
|
|
502
|
-
clock:
|
|
503
|
-
filter:
|
|
504
|
-
target:
|
|
553
|
+
let be = l(), xe = l();
|
|
554
|
+
u({
|
|
555
|
+
clock: A,
|
|
556
|
+
filter: F,
|
|
557
|
+
target: be
|
|
505
558
|
}), u({
|
|
506
|
-
clock:
|
|
559
|
+
clock: be,
|
|
507
560
|
filter: (e) => e === null,
|
|
508
|
-
target:
|
|
561
|
+
target: B
|
|
509
562
|
}), u({
|
|
510
|
-
clock:
|
|
563
|
+
clock: be,
|
|
511
564
|
filter: (e) => e !== null,
|
|
512
|
-
target:
|
|
565
|
+
target: xe
|
|
513
566
|
}), d({
|
|
514
|
-
source:
|
|
515
|
-
match: (e) => m(e) ? "condition" : h(e) ? "step" :
|
|
567
|
+
source: xe,
|
|
568
|
+
match: (e) => m(e) ? "condition" : h(e) ? "step" : g(e) ? "launchExperience" : _(e) ? "origin" : ee(e) ? "action" : "other",
|
|
516
569
|
cases: {
|
|
517
|
-
origin:
|
|
518
|
-
condition:
|
|
519
|
-
step:
|
|
520
|
-
launchExperience:
|
|
521
|
-
action:
|
|
570
|
+
origin: V,
|
|
571
|
+
condition: H,
|
|
572
|
+
step: z,
|
|
573
|
+
launchExperience: he,
|
|
574
|
+
action: U,
|
|
522
575
|
__: l()
|
|
523
576
|
}
|
|
524
577
|
}), u({
|
|
525
578
|
clock: [
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
531
|
-
G.doneData
|
|
579
|
+
V.doneData,
|
|
580
|
+
B.doneData,
|
|
581
|
+
Q.doneData,
|
|
582
|
+
Z.doneData,
|
|
583
|
+
K
|
|
532
584
|
],
|
|
533
585
|
filter: Boolean,
|
|
534
|
-
target:
|
|
535
|
-
})
|
|
586
|
+
target: ge
|
|
587
|
+
});
|
|
588
|
+
let Se = u({
|
|
536
589
|
clock: x,
|
|
537
|
-
|
|
590
|
+
filter: X
|
|
591
|
+
});
|
|
592
|
+
return u({
|
|
593
|
+
clock: Se,
|
|
594
|
+
target: Q
|
|
538
595
|
}), u({
|
|
539
|
-
clock:
|
|
540
|
-
source:
|
|
596
|
+
clock: Se,
|
|
597
|
+
source: j,
|
|
541
598
|
filter: Boolean,
|
|
542
|
-
target:
|
|
599
|
+
target: D.prepend((e) => ({
|
|
543
600
|
type: "step_submit",
|
|
544
601
|
step: e,
|
|
545
602
|
experience: $
|
|
546
603
|
}))
|
|
547
604
|
}), u({
|
|
548
|
-
clock:
|
|
549
|
-
source:
|
|
605
|
+
clock: Q.done,
|
|
606
|
+
source: j,
|
|
550
607
|
filter: Boolean,
|
|
551
|
-
target:
|
|
608
|
+
target: D.prepend((e) => ({
|
|
552
609
|
type: "step_submit_success",
|
|
553
610
|
step: e,
|
|
554
611
|
experience: $
|
|
555
612
|
}))
|
|
556
613
|
}), u({
|
|
557
|
-
clock:
|
|
558
|
-
source:
|
|
614
|
+
clock: Q.fail,
|
|
615
|
+
source: j,
|
|
559
616
|
filter: Boolean,
|
|
560
|
-
target:
|
|
617
|
+
target: D.prepend((e) => ({
|
|
561
618
|
type: "step_submit_error",
|
|
562
619
|
step: e,
|
|
563
620
|
experience: $
|
|
564
621
|
}))
|
|
565
622
|
}), u({
|
|
566
623
|
clock: S,
|
|
567
|
-
target:
|
|
624
|
+
target: R
|
|
568
625
|
}), u({
|
|
569
626
|
clock: C,
|
|
570
|
-
|
|
627
|
+
filter: X,
|
|
628
|
+
target: se
|
|
571
629
|
}), u({
|
|
572
630
|
clock: w,
|
|
573
|
-
|
|
631
|
+
filter: X,
|
|
632
|
+
target: ce
|
|
574
633
|
}), u({
|
|
575
634
|
source: a([
|
|
576
|
-
|
|
577
|
-
|
|
578
|
-
|
|
579
|
-
|
|
580
|
-
|
|
581
|
-
G.pending
|
|
635
|
+
V.pending,
|
|
636
|
+
B.pending,
|
|
637
|
+
Q.pending,
|
|
638
|
+
Z.pending,
|
|
639
|
+
me
|
|
582
640
|
]),
|
|
583
641
|
fn: (e) => e.some(Boolean) ? "transitioning" : "ready",
|
|
584
|
-
target:
|
|
642
|
+
target: ne
|
|
585
643
|
}), u({
|
|
586
|
-
clock:
|
|
587
|
-
source:
|
|
644
|
+
clock: z.doneData,
|
|
645
|
+
source: j,
|
|
588
646
|
filter: Boolean,
|
|
589
|
-
target:
|
|
647
|
+
target: D.prepend((e) => ({
|
|
590
648
|
type: "step_enter",
|
|
591
649
|
step: e,
|
|
592
650
|
experience: $
|
|
593
651
|
}))
|
|
594
652
|
}), u({
|
|
595
653
|
clock: E,
|
|
596
|
-
target:
|
|
654
|
+
target: _e
|
|
597
655
|
}), u({
|
|
598
|
-
clock:
|
|
599
|
-
filter:
|
|
656
|
+
clock: _e.doneData,
|
|
657
|
+
filter: F,
|
|
600
658
|
fn: Boolean,
|
|
601
|
-
target:
|
|
659
|
+
target: I
|
|
602
660
|
}), u({
|
|
603
|
-
source:
|
|
661
|
+
source: A,
|
|
604
662
|
clock: b,
|
|
605
|
-
filter: (e) => !e ||
|
|
606
|
-
target:
|
|
663
|
+
filter: (e) => !e || _(e),
|
|
664
|
+
target: Z
|
|
607
665
|
}), u({
|
|
608
|
-
source:
|
|
666
|
+
source: I,
|
|
609
667
|
filter: Boolean,
|
|
610
668
|
target: b
|
|
611
669
|
}), u({
|
|
612
|
-
source:
|
|
670
|
+
source: I,
|
|
613
671
|
filter: Boolean,
|
|
614
|
-
target:
|
|
672
|
+
target: D.prepend(() => ({
|
|
615
673
|
type: "experience_open",
|
|
616
674
|
experience: $
|
|
617
675
|
}))
|
|
618
676
|
}), u({
|
|
619
|
-
source:
|
|
677
|
+
source: I,
|
|
620
678
|
filter: (e) => !e,
|
|
621
|
-
target:
|
|
679
|
+
target: D.prepend(() => ({
|
|
622
680
|
type: "experience_close",
|
|
623
681
|
experience: $
|
|
624
682
|
}))
|
|
625
683
|
}), u({
|
|
626
|
-
clock:
|
|
627
|
-
filter:
|
|
684
|
+
clock: D,
|
|
685
|
+
filter: F,
|
|
628
686
|
target: r.eventBus
|
|
629
|
-
}), v ?
|
|
630
|
-
e &&
|
|
687
|
+
}), v ? Y.set($, (e) => {
|
|
688
|
+
e && L.close(), te(e), e && E();
|
|
631
689
|
}) : u({
|
|
632
690
|
clock: T,
|
|
633
691
|
target: E
|
|
634
692
|
}), T(), $;
|
|
635
693
|
});
|
|
636
|
-
function
|
|
637
|
-
return p(
|
|
694
|
+
function X(e) {
|
|
695
|
+
return p(me, e);
|
|
638
696
|
}
|
|
639
|
-
var
|
|
640
|
-
let t =
|
|
697
|
+
var he = f(({ client: e }) => {
|
|
698
|
+
let t = J.store({}), n = l(), i = l(), a = l(), s = o(t, {
|
|
641
699
|
register(e, t) {
|
|
642
700
|
let n = [...e[t.experienceId] ?? []];
|
|
643
701
|
return n.push(t), {
|
|
@@ -652,7 +710,7 @@ var $ = f(({ client: e }) => {
|
|
|
652
710
|
[n]: r ?? []
|
|
653
711
|
};
|
|
654
712
|
}
|
|
655
|
-
}), d = c(({ experience: t, target: n, options: r }) =>
|
|
713
|
+
}), d = c(({ experience: t, target: n, options: r }) => X({
|
|
656
714
|
client: e,
|
|
657
715
|
experience: t,
|
|
658
716
|
target: n,
|
|
@@ -691,16 +749,16 @@ var $ = f(({ client: e }) => {
|
|
|
691
749
|
clock: i,
|
|
692
750
|
target: h
|
|
693
751
|
});
|
|
694
|
-
function
|
|
752
|
+
function g(e, t, r) {
|
|
695
753
|
n({
|
|
696
754
|
experience: e,
|
|
697
755
|
target: t,
|
|
698
756
|
options: r
|
|
699
757
|
});
|
|
700
758
|
}
|
|
701
|
-
let
|
|
702
|
-
function
|
|
703
|
-
return
|
|
759
|
+
let _ = t.map((e) => Object.values(e).flat());
|
|
760
|
+
function ee(e) {
|
|
761
|
+
return _.map((t) => t.filter((t) => t.experienceKey === e), { skipVoid: !1 });
|
|
704
762
|
}
|
|
705
763
|
function v(e) {
|
|
706
764
|
return t.map((t) => t[e] || [], { skipVoid: !1 });
|
|
@@ -710,9 +768,9 @@ var $ = f(({ client: e }) => {
|
|
|
710
768
|
return y.has(t) || (s.register(t), e.eventBus({
|
|
711
769
|
type: "experience_initialize",
|
|
712
770
|
experience: t
|
|
713
|
-
}),
|
|
771
|
+
}), Y.get(t)?.(!0)), y.set(t, !0), () => {
|
|
714
772
|
y.has(t) && (y.set(t, !1), queueMicrotask(() => {
|
|
715
|
-
y.get(t) === !1 && (y.delete(t),
|
|
773
|
+
y.get(t) === !1 && (y.delete(t), Y.get(t)?.(!1), s.unregister(t), e.eventBus({
|
|
716
774
|
type: "experience_unmount",
|
|
717
775
|
experience: t
|
|
718
776
|
}));
|
|
@@ -720,15 +778,15 @@ var $ = f(({ client: e }) => {
|
|
|
720
778
|
};
|
|
721
779
|
}
|
|
722
780
|
return {
|
|
723
|
-
spawn:
|
|
781
|
+
spawn: g,
|
|
724
782
|
adopt: b,
|
|
725
|
-
getByExperienceKey:
|
|
783
|
+
getByExperienceKey: ee,
|
|
726
784
|
getByExperienceId: v,
|
|
727
|
-
listStore:
|
|
785
|
+
listStore: _
|
|
728
786
|
};
|
|
729
787
|
});
|
|
730
|
-
function
|
|
731
|
-
return p(
|
|
788
|
+
function Z(e) {
|
|
789
|
+
return p(he, e);
|
|
732
790
|
}
|
|
733
791
|
//#endregion
|
|
734
|
-
export {
|
|
792
|
+
export { se as a, W as c, h as d, G as i, ie as l, Z as n, le as o, z as r, H as s, X as t, m as u };
|