@picked/client 0.0.1-dev.1784001148032 → 0.0.1-dev.1784003142683
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/{api-BJ8EHkg5.js → api-CsddE4DI.js} +1 -1
- package/dist/{api-B1wdTDNv.cjs → api-U2LgcKqF.cjs} +1 -1
- package/dist/cjs/index.js +1 -1
- package/dist/cjs/plugins/dynamic-experiences/index.js +1 -1
- package/dist/cjs/server/index.js +1 -1
- package/dist/docs/actions.mdx +16 -2
- package/dist/docs/sdk/actions.md +33 -3
- package/dist/esm/index.js +32 -28
- package/dist/esm/plugins/dynamic-experiences/index.js +2 -2
- package/dist/esm/server/index.js +2 -2
- package/dist/experience-instance-BWL-yghq.cjs +1 -0
- package/dist/{experience-instance-M2kR3nTp.js → experience-instance-QSrdjfn6.js} +196 -168
- package/dist/{plugin-D3z3IXOb.cjs → plugin-CWvFEvt5.cjs} +1 -1
- package/dist/{plugin-B04iPuj_.js → plugin-CnCP2N-8.js} +1 -1
- package/dist/types/entities/action/action.d.ts +7 -1
- package/dist/types/entities/action/action.d.ts.map +1 -1
- package/dist/types/entities/experience-instance/experience-instance.d.ts +10 -0
- package/dist/types/entities/experience-instance/experience-instance.d.ts.map +1 -1
- package/dist/types/entities/history/history.d.ts +20 -3
- package/dist/types/entities/history/history.d.ts.map +1 -1
- package/dist/types/lifecycle/condition-selection.d.ts.map +1 -1
- package/dist/types/picked.d.ts +9 -1
- package/dist/types/picked.d.ts.map +1 -1
- package/dist/types/utils/node-tree/get-next-node-from-action.d.ts +24 -0
- package/dist/types/utils/node-tree/get-next-node-from-action.d.ts.map +1 -0
- package/package.json +1 -1
- package/dist/experience-instance-BbSXoRrr.cjs +0 -1
|
@@ -2,53 +2,53 @@ import { n as e, t } from "./rules-logic-HesIUCu6.js";
|
|
|
2
2
|
import "./logger-DMN6TxJJ.js";
|
|
3
3
|
import { n, s as r } from "./dom-CZyRgp2P.js";
|
|
4
4
|
import { t as i } from "./id-Bo4RBeOs.js";
|
|
5
|
-
import { attach as a, combine as o, createApi as s, createDomain as c, createEffect as l, createEvent as u, sample as d, split as
|
|
6
|
-
import { createFactory as
|
|
5
|
+
import { attach as a, combine as o, createApi as s, createDomain as c, createEffect as l, createEvent as u, sample as d, split as f } from "effector";
|
|
6
|
+
import { createFactory as p, invoke as m } from "@withease/factories";
|
|
7
7
|
//#region src/utils/nodes.ts
|
|
8
|
-
function
|
|
8
|
+
function h(e) {
|
|
9
9
|
return e.type === "condition";
|
|
10
10
|
}
|
|
11
|
-
function
|
|
11
|
+
function g(e) {
|
|
12
12
|
return e.type === "step";
|
|
13
13
|
}
|
|
14
|
-
function
|
|
14
|
+
function _(e) {
|
|
15
15
|
return e.type === "experience";
|
|
16
16
|
}
|
|
17
|
-
function
|
|
17
|
+
function v(e) {
|
|
18
18
|
return e.type === "origin";
|
|
19
19
|
}
|
|
20
|
-
function
|
|
20
|
+
function y(e) {
|
|
21
21
|
return e.type === "action";
|
|
22
22
|
}
|
|
23
23
|
//#endregion
|
|
24
24
|
//#region src/lifecycle/condition-selection.ts
|
|
25
|
-
var
|
|
26
|
-
function
|
|
25
|
+
var b = "conditions.", x = c("condition-results");
|
|
26
|
+
function S(e) {
|
|
27
27
|
return typeof e == "object" && !!e && !Array.isArray(e);
|
|
28
28
|
}
|
|
29
|
-
function
|
|
29
|
+
function C(e) {
|
|
30
30
|
if (e === void 0) return null;
|
|
31
|
-
if (Array.isArray(e)) return e.map((e) =>
|
|
32
|
-
if (
|
|
31
|
+
if (Array.isArray(e)) return e.map((e) => C(e));
|
|
32
|
+
if (S(e)) {
|
|
33
33
|
let t = Object.keys(e).sort((e, t) => e.localeCompare(t)), n = {};
|
|
34
|
-
for (let r of t) n[r] =
|
|
34
|
+
for (let r of t) n[r] = C(e[r]);
|
|
35
35
|
return n;
|
|
36
36
|
}
|
|
37
37
|
return e;
|
|
38
38
|
}
|
|
39
|
-
function
|
|
40
|
-
return JSON.stringify(
|
|
39
|
+
function w(e) {
|
|
40
|
+
return JSON.stringify(C(e));
|
|
41
41
|
}
|
|
42
|
-
var
|
|
43
|
-
let e =
|
|
42
|
+
var T = p(() => {
|
|
43
|
+
let e = x.store({}), t = s(e, {
|
|
44
44
|
set(e, t) {
|
|
45
|
-
return {
|
|
45
|
+
return e[t.hash] === t.result ? e : {
|
|
46
46
|
...e,
|
|
47
47
|
[t.hash]: t.result
|
|
48
48
|
};
|
|
49
49
|
},
|
|
50
50
|
seed(e, t) {
|
|
51
|
-
return {
|
|
51
|
+
return Object.keys(t).every((n) => e[n] === t[n]) ? e : {
|
|
52
52
|
...e,
|
|
53
53
|
...t
|
|
54
54
|
};
|
|
@@ -77,71 +77,71 @@ var w = f(() => {
|
|
|
77
77
|
reset: i
|
|
78
78
|
};
|
|
79
79
|
});
|
|
80
|
-
function
|
|
81
|
-
return
|
|
80
|
+
function E() {
|
|
81
|
+
return m(T);
|
|
82
82
|
}
|
|
83
|
-
async function
|
|
83
|
+
async function D(n, r, i) {
|
|
84
84
|
return r == null ? !0 : typeof r == "boolean" ? r : e(r) ? await t(n, r, i) === !0 : !0;
|
|
85
85
|
}
|
|
86
|
-
function
|
|
86
|
+
function O(e) {
|
|
87
87
|
if (typeof e == "string") return e;
|
|
88
88
|
if (Array.isArray(e) && typeof e[0] == "string") return e[0];
|
|
89
89
|
}
|
|
90
|
-
function
|
|
91
|
-
if (Array.isArray(e)) return e.some(
|
|
92
|
-
if (
|
|
93
|
-
let t =
|
|
94
|
-
return t !== void 0 && (t === "actions" || t.startsWith("actions.")) ? !0 : Object.values(e).some(
|
|
90
|
+
function k(e) {
|
|
91
|
+
if (Array.isArray(e)) return e.some(k);
|
|
92
|
+
if (S(e)) {
|
|
93
|
+
let t = O(e.var);
|
|
94
|
+
return t !== void 0 && (t === "actions" || t.startsWith("actions.")) ? !0 : Object.values(e).some(k);
|
|
95
95
|
}
|
|
96
96
|
return !1;
|
|
97
97
|
}
|
|
98
|
-
function
|
|
99
|
-
if (Array.isArray(e)) return e.flatMap(
|
|
100
|
-
if (
|
|
101
|
-
let t =
|
|
102
|
-
return [...t !== void 0 && t.startsWith(
|
|
98
|
+
function A(e) {
|
|
99
|
+
if (Array.isArray(e)) return e.flatMap(A);
|
|
100
|
+
if (S(e)) {
|
|
101
|
+
let t = O(e.var);
|
|
102
|
+
return [...t !== void 0 && t.startsWith(b) ? [t.slice(11)] : [], ...Object.values(e).flatMap(A)];
|
|
103
103
|
}
|
|
104
104
|
return [];
|
|
105
105
|
}
|
|
106
|
-
function
|
|
107
|
-
if (
|
|
108
|
-
for (let r of
|
|
106
|
+
function j(e, t, n = /* @__PURE__ */ new Set()) {
|
|
107
|
+
if (k(e)) return !0;
|
|
108
|
+
for (let r of A(e)) {
|
|
109
109
|
if (n.has(r)) continue;
|
|
110
110
|
n.add(r);
|
|
111
111
|
let e = t[r];
|
|
112
|
-
if (e !== void 0 &&
|
|
112
|
+
if (e !== void 0 && j(e.logic, t, n)) return !0;
|
|
113
113
|
}
|
|
114
114
|
return !1;
|
|
115
115
|
}
|
|
116
|
-
async function
|
|
116
|
+
async function M(e, t, n) {
|
|
117
117
|
let r = {};
|
|
118
118
|
for (let t of e.conditions.listStore.getState()) r[t.key] = t;
|
|
119
|
-
let i =
|
|
119
|
+
let i = j(t, r), a = w(t);
|
|
120
120
|
if (!i) {
|
|
121
121
|
let t = e.conditionResults.peek(a);
|
|
122
122
|
if (t !== void 0) return t;
|
|
123
123
|
}
|
|
124
|
-
let o = await
|
|
124
|
+
let o = await D(e, t, n?.context);
|
|
125
125
|
return i || e.conditionResults.set({
|
|
126
126
|
hash: a,
|
|
127
127
|
result: o
|
|
128
128
|
}), o;
|
|
129
129
|
}
|
|
130
|
-
async function
|
|
130
|
+
async function N(e, t, n) {
|
|
131
131
|
let r = n?.context, i = [
|
|
132
132
|
n?.precondition,
|
|
133
133
|
n?.condition,
|
|
134
134
|
t.condition
|
|
135
135
|
];
|
|
136
|
-
for (let t of i) if (!await
|
|
136
|
+
for (let t of i) if (!await M(e, t, { context: r })) return !1;
|
|
137
137
|
return !0;
|
|
138
138
|
}
|
|
139
139
|
//#endregion
|
|
140
140
|
//#region src/utils/node-tree/next-reachable-step-nodes.ts
|
|
141
|
-
var
|
|
141
|
+
var P = (e, t, n, r, i = /* @__PURE__ */ new Set()) => i.has(n.id) ? [] : (i.add(n.id), g(n) && !r ? [n] : t.filter((e) => e.sourceNodeId === n.id).flatMap((n) => {
|
|
142
142
|
let r = e.find((e) => e.id === n.destinationNodeId);
|
|
143
|
-
return r ?
|
|
144
|
-
})),
|
|
143
|
+
return r ? P(e, t, r, !1, i) : [];
|
|
144
|
+
})), ee = (e, t, n) => P(e, t, n, !0, /* @__PURE__ */ new Set()), F = (e, t, n, r, i = /* @__PURE__ */ new Set()) => {
|
|
145
145
|
if (i.has(n.id)) return [-1, -1];
|
|
146
146
|
i.add(n.id);
|
|
147
147
|
let a = t.filter((e) => e.sourceNodeId === n.id);
|
|
@@ -150,11 +150,11 @@ var N = (e, t, n, r, i = /* @__PURE__ */ new Set()) => i.has(n.id) ? [] : (i.add
|
|
|
150
150
|
for (let n of a) {
|
|
151
151
|
let r = e.find((e) => e.id === n.destinationNodeId);
|
|
152
152
|
if (!r) continue;
|
|
153
|
-
let [a, c] =
|
|
153
|
+
let [a, c] = F(e, t, r, !1, new Set(i));
|
|
154
154
|
a !== -1 && (o = Math.min(o, a + 1), s = Math.max(s, c + 1));
|
|
155
155
|
}
|
|
156
156
|
return o === Infinity ? [-1, -1] : [o, s];
|
|
157
|
-
},
|
|
157
|
+
}, te = (e, t, n) => F(e, t, n, !0, /* @__PURE__ */ new Set()), I = (e, t, n, r = /* @__PURE__ */ new Set()) => {
|
|
158
158
|
if (r.has(n.id)) return [-1, -1];
|
|
159
159
|
if (r.add(n.id), n.type === "origin") return [0, 0];
|
|
160
160
|
let i = t.filter((e) => e.destinationNodeId === n.id);
|
|
@@ -163,12 +163,12 @@ var N = (e, t, n, r, i = /* @__PURE__ */ new Set()) => i.has(n.id) ? [] : (i.add
|
|
|
163
163
|
for (let n of i) {
|
|
164
164
|
let i = e.find((e) => e.id === n.sourceNodeId);
|
|
165
165
|
if (!i) continue;
|
|
166
|
-
let [s, c] =
|
|
166
|
+
let [s, c] = I(e, t, i, new Set(r));
|
|
167
167
|
s !== -1 && (a = Math.min(a, s + 1), o = Math.max(o, c + 1));
|
|
168
168
|
}
|
|
169
169
|
return a === Infinity ? [-1, -1] : [a, o];
|
|
170
|
-
},
|
|
171
|
-
if (!e) return
|
|
170
|
+
}, ne = (e, t, n) => I(e, t, n, /* @__PURE__ */ new Set()), re = (e) => e.find((e) => e.type === "origin") || null, L = (e, t, n) => {
|
|
171
|
+
if (!e) return re(t);
|
|
172
172
|
let r = n.find((t) => t.sourceNodeId === e.id);
|
|
173
173
|
return r && t.find((e) => e.id === r.destinationNodeId) || null;
|
|
174
174
|
};
|
|
@@ -179,54 +179,79 @@ async function ie(e, t, n, r) {
|
|
|
179
179
|
return n.find((e) => e.id === a?.destinationNodeId);
|
|
180
180
|
}
|
|
181
181
|
//#endregion
|
|
182
|
-
//#region src/
|
|
182
|
+
//#region src/utils/node-tree/get-next-node-from-action.ts
|
|
183
183
|
function R(e, t, n, r) {
|
|
184
|
-
let i =
|
|
185
|
-
return
|
|
184
|
+
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);
|
|
185
|
+
return n.find((e) => e.id === o?.destinationNodeId);
|
|
186
186
|
}
|
|
187
|
-
|
|
188
|
-
|
|
187
|
+
//#endregion
|
|
188
|
+
//#region src/entities/experience-instance/experience-instance.ts
|
|
189
|
+
var z = c("experience-instance"), B = p(({ client: r, experience: c, target: p, options: m }) => {
|
|
190
|
+
let b = i("exp-instance");
|
|
189
191
|
r.history.seedInstanceFromSnapshot({
|
|
190
|
-
instanceId:
|
|
192
|
+
instanceId: b,
|
|
191
193
|
experienceId: c.id
|
|
192
194
|
});
|
|
193
|
-
let
|
|
195
|
+
let x = u(), S = u(), C = u(), w = u(), T = u(), E = u(), D = u(), O = u(), k = u(), A = c.componentStore, j = z.store("transitioning"), M = r.history.entriesStore.map((e) => e.filter((e) => e.instanceId === b)), N = M.map((e) => e.filter((e) => g(e.node))), P = N.map((e) => e.length >= 2), F = M.map((e) => e.at(-1)?.node || null), I = z.store(null);
|
|
196
|
+
d({
|
|
197
|
+
clock: [F, r.steps.listStore],
|
|
198
|
+
source: {
|
|
199
|
+
steps: r.steps.listStore,
|
|
200
|
+
node: F
|
|
201
|
+
},
|
|
202
|
+
filter: ({ node: e }) => e !== null && g(e),
|
|
203
|
+
fn: ({ steps: e, node: t }) => t && g(t) ? e.find((e) => e.id === t.stepId) ?? null : null,
|
|
204
|
+
target: I
|
|
205
|
+
});
|
|
206
|
+
let B = o(r.steps.listStore, N, (e, t) => {
|
|
194
207
|
let n = t.at(-2);
|
|
195
|
-
if (!n || !
|
|
208
|
+
if (!n || !g(n.node)) return null;
|
|
196
209
|
let r = n.node;
|
|
197
210
|
return e.find((e) => e.id === r.stepId) || null;
|
|
198
|
-
}),
|
|
211
|
+
}), V = o(c.treeStore, F, ({ nodes: e, edges: t }, n) => n ? ee(e, t, n) : []), H = o(c.treeStore, F, ({ nodes: e, edges: t }, n) => n ? ne(e, t, n) : [-1, -1]), ae = o(c.treeStore, F, ({ nodes: e, edges: t }, n) => n ? te(e, t, n) : [-1, -1]), U = z.store(!1), W = s(U, {
|
|
199
212
|
open: () => !0,
|
|
200
213
|
close: () => !1,
|
|
201
214
|
toggle: (e) => !e,
|
|
202
215
|
set: (e, t) => t
|
|
203
|
-
}),
|
|
204
|
-
r.history.back({ instanceId:
|
|
205
|
-
}),
|
|
216
|
+
}), oe = l(() => {
|
|
217
|
+
r.history.back({ instanceId: b });
|
|
218
|
+
}), se = a({
|
|
206
219
|
source: c.treeStore,
|
|
207
220
|
effect: (e, t) => {
|
|
208
|
-
let n = e.nodes.find((e) =>
|
|
221
|
+
let n = e.nodes.find((e) => g(e) && e.stepId === t);
|
|
209
222
|
n && r.history.push({
|
|
210
|
-
instanceId:
|
|
223
|
+
instanceId: b,
|
|
211
224
|
experienceId: c.id,
|
|
212
225
|
node: n
|
|
213
226
|
});
|
|
214
227
|
}
|
|
228
|
+
}), ce = a({
|
|
229
|
+
source: c.treeStore,
|
|
230
|
+
effect: (e, t) => {
|
|
231
|
+
let n = e.steps.find((e) => e.key === t);
|
|
232
|
+
if (!n) return;
|
|
233
|
+
let i = e.nodes.find((e) => g(e) && e.stepId === n.id);
|
|
234
|
+
i && r.history.push({
|
|
235
|
+
instanceId: b,
|
|
236
|
+
experienceId: c.id,
|
|
237
|
+
node: i
|
|
238
|
+
});
|
|
239
|
+
}
|
|
215
240
|
}), G = a({
|
|
216
|
-
source:
|
|
241
|
+
source: F,
|
|
217
242
|
effect: (e) => {}
|
|
218
243
|
}), K = a({
|
|
219
244
|
source: c.treeStore,
|
|
220
|
-
effect: async ({ nodes: e }) =>
|
|
245
|
+
effect: async ({ nodes: e }) => re(e)
|
|
221
246
|
}), q = a({
|
|
222
247
|
source: c.treeStore,
|
|
223
248
|
effect: async ({ nodes: e, edges: t }, n) => {
|
|
224
|
-
if (
|
|
249
|
+
if (v(n)) return L(n, e, t);
|
|
225
250
|
}
|
|
226
251
|
}), J = a({
|
|
227
252
|
source: c.treeStore,
|
|
228
253
|
effect: async ({ nodes: e, edges: n, conditions: i }, a) => {
|
|
229
|
-
if (!
|
|
254
|
+
if (!h(a)) return;
|
|
230
255
|
let o = i.find((e) => e.id === a.conditionId)?.logic;
|
|
231
256
|
return o ? ie(!!await t(r, o), a.id, e, n) : void 0;
|
|
232
257
|
}
|
|
@@ -238,99 +263,103 @@ var z = c("experience-instance"), B = f(({ client: r, experience: c, target: f,
|
|
|
238
263
|
},
|
|
239
264
|
effect: async ({ tree: e, actions: t, snapshot: n }, r) => {
|
|
240
265
|
let { nodes: i, edges: a } = e;
|
|
241
|
-
if (!
|
|
266
|
+
if (!y(r)) return;
|
|
242
267
|
let o = r.actionKey;
|
|
243
268
|
if (!o) {
|
|
244
269
|
`${r.id}`;
|
|
245
270
|
return;
|
|
246
271
|
}
|
|
247
272
|
let s = t.find((e) => e.key === o)?.action;
|
|
248
|
-
if (
|
|
273
|
+
if (typeof s != "function") return `${o}`, R(!1, r.id, i, a) ?? null;
|
|
274
|
+
let c = !0;
|
|
249
275
|
try {
|
|
250
276
|
`${o}`, await s({
|
|
251
277
|
...n,
|
|
252
278
|
args: []
|
|
253
279
|
}, { experience: Q });
|
|
254
|
-
let e = R(r, a, i, "true");
|
|
255
|
-
return e ? (`${o}${e.id}`, e) : (`${r.id}`, null);
|
|
256
280
|
} catch {
|
|
257
|
-
`${o}
|
|
258
|
-
|
|
259
|
-
|
|
281
|
+
`${o}`, c = !1;
|
|
282
|
+
}
|
|
283
|
+
let l = R(c, r.id, i, a);
|
|
284
|
+
if (!l) {
|
|
285
|
+
let e = a.some((e) => e.sourceNodeId === r.id) ? "no edge for its outcome" : "no outgoing edge";
|
|
286
|
+
return `${r.id}${e}`, null;
|
|
260
287
|
}
|
|
288
|
+
return `${o}${l.id}`, l;
|
|
261
289
|
}
|
|
262
|
-
}),
|
|
263
|
-
|
|
290
|
+
}), le = l((e) => {
|
|
291
|
+
_(e) && r.experiences.launch({ key: e.experienceKey });
|
|
264
292
|
}), X = a({
|
|
265
|
-
source: [
|
|
293
|
+
source: [F, c.treeStore],
|
|
266
294
|
effect: async ([e, { nodes: t, edges: n }]) => L(e, t, n)
|
|
267
295
|
}), Z = a({
|
|
268
|
-
source: [
|
|
296
|
+
source: [F, c.treeStore],
|
|
269
297
|
effect: async ([e, { nodes: t, edges: n }]) => L(e, t, n)
|
|
270
|
-
}),
|
|
298
|
+
}), ue = l((e) => {
|
|
271
299
|
r.history.push({
|
|
272
|
-
instanceId:
|
|
300
|
+
instanceId: b,
|
|
273
301
|
experienceId: c.id,
|
|
274
302
|
node: e
|
|
275
303
|
});
|
|
276
|
-
}),
|
|
304
|
+
}), de = a({
|
|
277
305
|
source: c.configStore,
|
|
278
|
-
effect: async ({ initializeOpenLogic: n }) =>
|
|
279
|
-
}),
|
|
306
|
+
effect: async ({ initializeOpenLogic: n }) => m?.initialiseOpen === void 0 ? e(n) ? !!await t(r, n) : n ?? !1 : m.initialiseOpen
|
|
307
|
+
}), fe = o(A, r.frameworks.listStore, (e, t) => {
|
|
280
308
|
if (!e) return null;
|
|
281
309
|
let n = t.find((t) => t.name === e.component.frameworkName);
|
|
282
310
|
return n ? {
|
|
283
311
|
component: e,
|
|
284
312
|
framework: n
|
|
285
313
|
} : null;
|
|
286
|
-
}, { skipVoid: !1 }), Q,
|
|
287
|
-
source:
|
|
314
|
+
}, { skipVoid: !1 }), Q, pe = a({
|
|
315
|
+
source: fe,
|
|
288
316
|
effect: (e) => {
|
|
289
317
|
if (!e) return;
|
|
290
|
-
if (!
|
|
318
|
+
if (!p) {
|
|
291
319
|
`${c.id}`;
|
|
292
320
|
return;
|
|
293
321
|
}
|
|
294
|
-
let t = n(
|
|
322
|
+
let t = n(p);
|
|
295
323
|
try {
|
|
296
324
|
e.framework.render(t, e.component.component, r, Q);
|
|
297
325
|
} catch {}
|
|
298
326
|
}
|
|
299
327
|
});
|
|
300
328
|
Q = Object.freeze({
|
|
301
|
-
id:
|
|
329
|
+
id: b,
|
|
302
330
|
experienceKey: c.key,
|
|
303
331
|
experienceId: c.id,
|
|
304
332
|
experienceName: c.name,
|
|
305
333
|
configStore: c.configStore,
|
|
306
|
-
target:
|
|
307
|
-
componentStore:
|
|
308
|
-
componentAndFrameworkStore:
|
|
309
|
-
stateStore:
|
|
334
|
+
target: p,
|
|
335
|
+
componentStore: A,
|
|
336
|
+
componentAndFrameworkStore: fe,
|
|
337
|
+
stateStore: j,
|
|
310
338
|
isOpenStore: U,
|
|
311
339
|
open: W.open,
|
|
312
340
|
close: W.close,
|
|
313
341
|
toggleOpen: W.toggle,
|
|
314
342
|
setOpen: W.set,
|
|
315
343
|
treeStore: c.treeStore,
|
|
316
|
-
currentNodeStore:
|
|
317
|
-
currentStepStore:
|
|
318
|
-
previousStepStore:
|
|
319
|
-
nextReachableStepNodesStore:
|
|
320
|
-
stepsToOriginStore:
|
|
321
|
-
stepsToLeafStore:
|
|
322
|
-
goToNextStep:
|
|
323
|
-
goToPreviousStep:
|
|
324
|
-
goToStepById:
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
344
|
+
currentNodeStore: F,
|
|
345
|
+
currentStepStore: I,
|
|
346
|
+
previousStepStore: B,
|
|
347
|
+
nextReachableStepNodesStore: V,
|
|
348
|
+
stepsToOriginStore: H,
|
|
349
|
+
stepsToLeafStore: ae,
|
|
350
|
+
goToNextStep: S,
|
|
351
|
+
goToPreviousStep: C,
|
|
352
|
+
goToStepById: w,
|
|
353
|
+
goToStepByKey: T,
|
|
354
|
+
reset: E,
|
|
355
|
+
stepsHistoryStore: N,
|
|
356
|
+
isResumableStore: P,
|
|
357
|
+
restart: D,
|
|
358
|
+
mountFx: pe
|
|
330
359
|
});
|
|
331
|
-
let $ = u(),
|
|
332
|
-
d({
|
|
333
|
-
clock:
|
|
360
|
+
let $ = u(), me = u();
|
|
361
|
+
return d({
|
|
362
|
+
clock: F,
|
|
334
363
|
target: $
|
|
335
364
|
}), d({
|
|
336
365
|
clock: $,
|
|
@@ -339,15 +368,15 @@ var z = c("experience-instance"), B = f(({ client: r, experience: c, target: f,
|
|
|
339
368
|
}), d({
|
|
340
369
|
clock: $,
|
|
341
370
|
filter: (e) => e !== null,
|
|
342
|
-
target:
|
|
343
|
-
}),
|
|
344
|
-
source:
|
|
345
|
-
match: (e) =>
|
|
371
|
+
target: me
|
|
372
|
+
}), f({
|
|
373
|
+
source: me,
|
|
374
|
+
match: (e) => h(e) ? "condition" : g(e) ? "step" : _(e) ? "launchExperience" : v(e) ? "origin" : y(e) ? "action" : "other",
|
|
346
375
|
cases: {
|
|
347
376
|
origin: q,
|
|
348
377
|
condition: J,
|
|
349
378
|
step: G,
|
|
350
|
-
launchExperience:
|
|
379
|
+
launchExperience: le,
|
|
351
380
|
action: Y,
|
|
352
381
|
__: u()
|
|
353
382
|
}
|
|
@@ -361,13 +390,13 @@ var z = c("experience-instance"), B = f(({ client: r, experience: c, target: f,
|
|
|
361
390
|
Y.doneData
|
|
362
391
|
],
|
|
363
392
|
filter: Boolean,
|
|
364
|
-
target:
|
|
393
|
+
target: ue
|
|
365
394
|
}), d({
|
|
366
|
-
clock:
|
|
395
|
+
clock: S,
|
|
367
396
|
target: Z
|
|
368
397
|
}), d({
|
|
369
|
-
clock:
|
|
370
|
-
source:
|
|
398
|
+
clock: S,
|
|
399
|
+
source: I,
|
|
371
400
|
filter: Boolean,
|
|
372
401
|
target: r.eventBus.prepend((e) => ({
|
|
373
402
|
type: "step_submit",
|
|
@@ -376,7 +405,7 @@ var z = c("experience-instance"), B = f(({ client: r, experience: c, target: f,
|
|
|
376
405
|
}))
|
|
377
406
|
}), d({
|
|
378
407
|
clock: Z.done,
|
|
379
|
-
source:
|
|
408
|
+
source: I,
|
|
380
409
|
filter: Boolean,
|
|
381
410
|
target: r.eventBus.prepend((e) => ({
|
|
382
411
|
type: "step_submit_success",
|
|
@@ -385,46 +414,45 @@ var z = c("experience-instance"), B = f(({ client: r, experience: c, target: f,
|
|
|
385
414
|
}))
|
|
386
415
|
}), d({
|
|
387
416
|
clock: Z.fail,
|
|
388
|
-
source:
|
|
417
|
+
source: I,
|
|
389
418
|
filter: Boolean,
|
|
390
419
|
target: r.eventBus.prepend((e) => ({
|
|
391
420
|
type: "step_submit_error",
|
|
392
421
|
step: e,
|
|
393
422
|
experience: Q
|
|
394
423
|
}))
|
|
395
|
-
}), d({
|
|
396
|
-
clock: S,
|
|
397
|
-
target: ae
|
|
398
424
|
}), d({
|
|
399
425
|
clock: C,
|
|
400
426
|
target: oe
|
|
401
427
|
}), d({
|
|
402
428
|
clock: w,
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
});
|
|
406
|
-
let pe = l(() => {
|
|
407
|
-
r.responses.clearByExperience(c.id);
|
|
408
|
-
});
|
|
409
|
-
return d({
|
|
429
|
+
target: se
|
|
430
|
+
}), d({
|
|
410
431
|
clock: T,
|
|
411
|
-
|
|
432
|
+
target: ce
|
|
433
|
+
}), d({
|
|
434
|
+
clock: [E, D],
|
|
435
|
+
fn: () => ({ instanceId: b }),
|
|
412
436
|
target: r.history.clearForInstance
|
|
413
437
|
}), d({
|
|
414
|
-
clock:
|
|
415
|
-
target:
|
|
438
|
+
clock: D,
|
|
439
|
+
target: l(() => {
|
|
440
|
+
r.responses.clearByExperience(c.id);
|
|
441
|
+
})
|
|
416
442
|
}), d({
|
|
417
443
|
source: o([
|
|
418
444
|
J.pending,
|
|
419
445
|
q.pending,
|
|
420
446
|
K.pending,
|
|
421
|
-
Z.pending
|
|
447
|
+
Z.pending,
|
|
448
|
+
X.pending,
|
|
449
|
+
Y.pending
|
|
422
450
|
]),
|
|
423
451
|
fn: (e) => e.some(Boolean) ? "transitioning" : "ready",
|
|
424
|
-
target:
|
|
452
|
+
target: j
|
|
425
453
|
}), d({
|
|
426
454
|
clock: G.doneData,
|
|
427
|
-
source:
|
|
455
|
+
source: I,
|
|
428
456
|
filter: Boolean,
|
|
429
457
|
target: r.eventBus.prepend((e) => ({
|
|
430
458
|
type: "step_enter",
|
|
@@ -432,21 +460,21 @@ var z = c("experience-instance"), B = f(({ client: r, experience: c, target: f,
|
|
|
432
460
|
experience: Q
|
|
433
461
|
}))
|
|
434
462
|
}), d({
|
|
435
|
-
clock:
|
|
436
|
-
target:
|
|
463
|
+
clock: k,
|
|
464
|
+
target: de
|
|
437
465
|
}), d({
|
|
438
|
-
source:
|
|
466
|
+
source: de.doneData,
|
|
439
467
|
fn: Boolean,
|
|
440
468
|
target: U
|
|
441
469
|
}), d({
|
|
442
|
-
source:
|
|
443
|
-
clock:
|
|
444
|
-
filter: (e) => e ?
|
|
470
|
+
source: F,
|
|
471
|
+
clock: x,
|
|
472
|
+
filter: (e) => e ? v(e) : !0,
|
|
445
473
|
target: X
|
|
446
474
|
}), d({
|
|
447
475
|
source: U,
|
|
448
476
|
filter: Boolean,
|
|
449
|
-
target:
|
|
477
|
+
target: x
|
|
450
478
|
}), d({
|
|
451
479
|
source: U,
|
|
452
480
|
filter: Boolean,
|
|
@@ -462,14 +490,14 @@ var z = c("experience-instance"), B = f(({ client: r, experience: c, target: f,
|
|
|
462
490
|
experience: Q
|
|
463
491
|
}))
|
|
464
492
|
}), d({
|
|
465
|
-
clock:
|
|
466
|
-
target: [
|
|
467
|
-
}),
|
|
493
|
+
clock: O,
|
|
494
|
+
target: [k]
|
|
495
|
+
}), O(), Q;
|
|
468
496
|
});
|
|
469
497
|
function V(e) {
|
|
470
|
-
return
|
|
498
|
+
return m(B, e);
|
|
471
499
|
}
|
|
472
|
-
var H =
|
|
500
|
+
var H = p(({ client: e }) => {
|
|
473
501
|
let t = z.store({}), n = u(), i = u(), a = u(), o = s(t, {
|
|
474
502
|
register(e, t) {
|
|
475
503
|
let n = [...e[t.experienceId] ?? []];
|
|
@@ -490,15 +518,15 @@ var H = f(({ client: e }) => {
|
|
|
490
518
|
experience: t,
|
|
491
519
|
target: n,
|
|
492
520
|
options: r
|
|
493
|
-
})),
|
|
521
|
+
})), f = l((e) => {
|
|
494
522
|
o.register(e);
|
|
495
|
-
}),
|
|
523
|
+
}), p = l((e) => {
|
|
496
524
|
e.target && r(e.target, () => {
|
|
497
525
|
a(e);
|
|
498
526
|
});
|
|
499
|
-
}),
|
|
527
|
+
}), m = l((e) => {
|
|
500
528
|
o.unregister(e);
|
|
501
|
-
}),
|
|
529
|
+
}), h = l(async (e) => {
|
|
502
530
|
await e.mountFx();
|
|
503
531
|
});
|
|
504
532
|
d({
|
|
@@ -506,12 +534,12 @@ var H = f(({ client: e }) => {
|
|
|
506
534
|
target: c
|
|
507
535
|
}), d({
|
|
508
536
|
clock: a,
|
|
509
|
-
target:
|
|
537
|
+
target: m
|
|
510
538
|
}), d({
|
|
511
539
|
clock: c.doneData,
|
|
512
540
|
target: [
|
|
513
|
-
ee,
|
|
514
541
|
f,
|
|
542
|
+
p,
|
|
515
543
|
i
|
|
516
544
|
]
|
|
517
545
|
}), d({
|
|
@@ -522,31 +550,31 @@ var H = f(({ client: e }) => {
|
|
|
522
550
|
}))
|
|
523
551
|
}), d({
|
|
524
552
|
clock: i,
|
|
525
|
-
target:
|
|
553
|
+
target: h
|
|
526
554
|
});
|
|
527
|
-
function
|
|
555
|
+
function g(e, t, r) {
|
|
528
556
|
n({
|
|
529
557
|
experience: e,
|
|
530
558
|
target: t,
|
|
531
559
|
options: r
|
|
532
560
|
});
|
|
533
561
|
}
|
|
534
|
-
let
|
|
535
|
-
function _(e) {
|
|
536
|
-
return g.map((t) => t.filter((t) => t.experienceKey === e), { skipVoid: !1 });
|
|
537
|
-
}
|
|
562
|
+
let _ = t.map((e) => Object.values(e).flat());
|
|
538
563
|
function v(e) {
|
|
564
|
+
return _.map((t) => t.filter((t) => t.experienceKey === e), { skipVoid: !1 });
|
|
565
|
+
}
|
|
566
|
+
function y(e) {
|
|
539
567
|
return t.map((t) => t[e] || [], { skipVoid: !1 });
|
|
540
568
|
}
|
|
541
569
|
return {
|
|
542
|
-
spawn:
|
|
543
|
-
getByExperienceKey:
|
|
544
|
-
getByExperienceId:
|
|
545
|
-
listStore:
|
|
570
|
+
spawn: g,
|
|
571
|
+
getByExperienceKey: v,
|
|
572
|
+
getByExperienceId: y,
|
|
573
|
+
listStore: _
|
|
546
574
|
};
|
|
547
575
|
});
|
|
548
|
-
function
|
|
549
|
-
return
|
|
576
|
+
function ae(e) {
|
|
577
|
+
return m(H, e);
|
|
550
578
|
}
|
|
551
579
|
//#endregion
|
|
552
|
-
export {
|
|
580
|
+
export { w as a, j as c, M as i, h as l, ae as n, N as o, E as r, k as s, V as t, g as u };
|