@picked/client 0.0.84-next.1 → 0.0.84-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-MpZsPlFm.js → api-CK-PXs5W.js} +1 -1
- package/dist/{api-fdr8U6uj.cjs → api-DYtAw2dj.cjs} +1 -1
- package/dist/cjs/index.js +2 -2
- package/dist/cjs/plugins/dynamic-experiences/index.js +1 -1
- package/dist/cjs/plugins/experience-browser-storage/index.js +1 -1
- package/dist/cjs/server/index.js +1 -1
- package/dist/docs/reference/sdk/analytics-events.md +11 -2
- package/dist/docs/reference/sdk/ssr/slots-and-placements.md +54 -0
- package/dist/docs/reference/tools/mcp.md +11 -5
- package/dist/esm/index.js +3 -3
- package/dist/esm/plugins/dynamic-experiences/index.js +2 -2
- package/dist/esm/plugins/experience-browser-storage/index.js +12 -10
- package/dist/esm/server/index.js +3 -3
- package/dist/experience-instance-DifOgdCW.cjs +1 -0
- package/dist/{experience-instance-BibCf-8y.js → experience-instance-VZQBpVEW.js} +265 -239
- package/dist/{plugin-CdfjHKod.js → plugin-B9lfuis6.js} +2 -2
- package/dist/{plugin-CP-W1V0R.cjs → plugin-DVgP93XD.cjs} +1 -1
- package/dist/{preview-unavailable-p5as3RNK.cjs → preview-unavailable-fSXfaDH1.cjs} +1 -1
- package/dist/{preview-unavailable-Cs6tiz5X.js → preview-unavailable-zPFlNuAC.js} +1 -1
- package/dist/{provider-Dk6CixDl.cjs → provider-0SD5Y2Ni.cjs} +1 -1
- package/dist/{provider-DUACzeBR.js → provider-CgheavUb.js} +1 -1
- package/dist/types/entities/experience-instance/experience-instance.d.ts +14 -1
- package/dist/types/entities/experience-instance/experience-instance.d.ts.map +1 -1
- package/dist/types/picked.d.ts +1 -0
- package/dist/types/picked.d.ts.map +1 -1
- package/dist/types/plugins/experience-browser-storage/plugin.d.ts.map +1 -1
- package/dist/types/utils/events.d.ts +4 -0
- package/dist/types/utils/events.d.ts.map +1 -1
- package/package.json +3 -3
- package/dist/experience-instance-CMfjyLaI.cjs +0 -1
|
@@ -10,18 +10,18 @@ function m(e) {
|
|
|
10
10
|
function h(e) {
|
|
11
11
|
return e.type === "step";
|
|
12
12
|
}
|
|
13
|
-
function
|
|
13
|
+
function ee(e) {
|
|
14
14
|
return e.type === "experience";
|
|
15
15
|
}
|
|
16
|
-
function
|
|
16
|
+
function g(e) {
|
|
17
17
|
return e.type === "origin";
|
|
18
18
|
}
|
|
19
|
-
function
|
|
19
|
+
function _(e) {
|
|
20
20
|
return e.type === "action";
|
|
21
21
|
}
|
|
22
22
|
//#endregion
|
|
23
23
|
//#region src/utils/node-tree/node-adjacency.ts
|
|
24
|
-
var
|
|
24
|
+
var v = [], y = (e, t) => {
|
|
25
25
|
let n = /* @__PURE__ */ new Map();
|
|
26
26
|
for (let t of e) n.set(t.id, t);
|
|
27
27
|
let r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
|
|
@@ -36,14 +36,14 @@ var y = [], b = (e, t) => {
|
|
|
36
36
|
outgoingEdges: r,
|
|
37
37
|
incomingEdges: i
|
|
38
38
|
};
|
|
39
|
-
},
|
|
39
|
+
}, b = (e, t) => e.outgoingEdges.get(t) ?? v, x = (e, t) => e.incomingEdges.get(t) ?? v, S = -1, C = -Infinity, w = (e, t) => Array.from({ length: e }, () => t), T = (e) => Array.from({ length: e }, () => !1), E = (e, t, n) => {
|
|
40
40
|
let r = [];
|
|
41
41
|
for (let i of e) {
|
|
42
42
|
let e = n.get(i[t]);
|
|
43
43
|
e !== void 0 && r.push(e);
|
|
44
44
|
}
|
|
45
45
|
return r;
|
|
46
|
-
},
|
|
46
|
+
}, D = (e, t) => {
|
|
47
47
|
let n = /* @__PURE__ */ new Map();
|
|
48
48
|
t.forEach((e, t) => {
|
|
49
49
|
n.set(e, t);
|
|
@@ -57,15 +57,15 @@ var y = [], b = (e, t) => {
|
|
|
57
57
|
origins: []
|
|
58
58
|
};
|
|
59
59
|
return t.forEach((t, i) => {
|
|
60
|
-
let a =
|
|
61
|
-
r.successors.push(
|
|
60
|
+
let a = b(e, t);
|
|
61
|
+
r.successors.push(E(a, "destinationNodeId", n)), r.predecessors.push(E(x(e, t), "sourceNodeId", n));
|
|
62
62
|
let o = a.length === 0;
|
|
63
63
|
r.isLeaf.push(o), o && r.leaves.push(i);
|
|
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
|
-
},
|
|
68
|
-
let r =
|
|
67
|
+
}, O = (e, t, n) => {
|
|
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;
|
|
71
71
|
for (; o < i.length;) {
|
|
@@ -73,144 +73,144 @@ var y = [], b = (e, t) => {
|
|
|
73
73
|
if (o += 1, e === void 0) continue;
|
|
74
74
|
a += 1;
|
|
75
75
|
let n = (r[e] ?? 0) + 1;
|
|
76
|
-
for (let a of t[e] ?? []) r[a] ===
|
|
76
|
+
for (let a of t[e] ?? []) r[a] === S && (r[a] = n, i.push(a));
|
|
77
77
|
}
|
|
78
78
|
return {
|
|
79
79
|
values: r,
|
|
80
80
|
visits: a
|
|
81
81
|
};
|
|
82
|
-
},
|
|
82
|
+
}, k = (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
|
+
}, te = (e, t) => {
|
|
88
88
|
let n = (e.successors[t.node] ?? [])[t.edge];
|
|
89
89
|
if (t.edge += 1, n !== void 0) {
|
|
90
|
-
if (e.discoveryOf[n] ===
|
|
91
|
-
|
|
90
|
+
if (e.discoveryOf[n] === S) {
|
|
91
|
+
k(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
|
+
}, ne = (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
|
+
}, A = (e, t) => {
|
|
104
104
|
let n = {
|
|
105
105
|
successors: e,
|
|
106
|
-
discoveryOf:
|
|
107
|
-
lowLinkOf:
|
|
108
|
-
onStack:
|
|
109
|
-
componentOf:
|
|
106
|
+
discoveryOf: w(t, S),
|
|
107
|
+
lowLinkOf: w(t, S),
|
|
108
|
+
onStack: T(t),
|
|
109
|
+
componentOf: w(t, S),
|
|
110
110
|
stack: [],
|
|
111
111
|
frames: [],
|
|
112
112
|
members: [],
|
|
113
113
|
counter: 0,
|
|
114
114
|
visits: 0
|
|
115
115
|
};
|
|
116
|
-
for (let r = 0; r < t; r += 1) if (n.discoveryOf[r] ===
|
|
116
|
+
for (let r = 0; r < t; r += 1) if (n.discoveryOf[r] === S) for (k(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 ? te(n, t) : ne(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
|
-
},
|
|
127
|
-
let r =
|
|
126
|
+
}, j = (e, t, n) => {
|
|
127
|
+
let r = C;
|
|
128
128
|
for (let i of e.adjacency[t] ?? []) {
|
|
129
|
-
let t = e.components.componentOf[i] ??
|
|
129
|
+
let t = e.components.componentOf[i] ?? S;
|
|
130
130
|
if (t === n) continue;
|
|
131
|
-
let a = e.perComponent[t] ??
|
|
132
|
-
a !==
|
|
131
|
+
let a = e.perComponent[t] ?? C;
|
|
132
|
+
a !== C && (r = Math.max(r, a + 1));
|
|
133
133
|
}
|
|
134
134
|
return r;
|
|
135
|
-
},
|
|
136
|
-
let n =
|
|
135
|
+
}, M = (e, t) => {
|
|
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, j(e, r, t));
|
|
143
143
|
}
|
|
144
144
|
return n;
|
|
145
|
-
},
|
|
145
|
+
}, N = (e, t, n, r) => {
|
|
146
146
|
let i = n.members.length, a = {
|
|
147
147
|
adjacency: e,
|
|
148
148
|
isTerminus: t,
|
|
149
149
|
components: n,
|
|
150
|
-
perComponent:
|
|
150
|
+
perComponent: w(i, C)
|
|
151
151
|
}, o = 0;
|
|
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 =
|
|
156
|
-
a.perComponent[t] = c ===
|
|
155
|
+
let c = M(a, t);
|
|
156
|
+
a.perComponent[t] = c === C ? C : c + s - 1;
|
|
157
157
|
}
|
|
158
158
|
return {
|
|
159
159
|
values: n.componentOf.map((e, n) => {
|
|
160
160
|
if (t[n]) return 0;
|
|
161
|
-
let r = a.perComponent[e] ??
|
|
162
|
-
return r ===
|
|
161
|
+
let r = a.perComponent[e] ?? C;
|
|
162
|
+
return r === C ? S : r;
|
|
163
163
|
}),
|
|
164
164
|
visits: o
|
|
165
165
|
};
|
|
166
|
-
},
|
|
166
|
+
}, P = (e, t, n) => {
|
|
167
167
|
let r = /* @__PURE__ */ new Map();
|
|
168
168
|
return e.forEach((e, i) => {
|
|
169
|
-
let a = t.values[i] ??
|
|
170
|
-
r.set(e, a ===
|
|
169
|
+
let a = t.values[i] ?? S, o = n.values[i] ?? S;
|
|
170
|
+
r.set(e, a === S ? [S, S] : [a, o]);
|
|
171
171
|
}), r;
|
|
172
|
-
},
|
|
173
|
-
let n =
|
|
172
|
+
}, re = (e, t) => {
|
|
173
|
+
let n = y(e, t), r = [...n.nodeById.keys()], i = r.length, a = D(n, r), o = A(a.successors, i), s = O(a.leaves, a.predecessors, i), c = N(a.successors, a.isLeaf, o, !1), l = O(a.origins, a.successors, i), u = N(a.predecessors, a.isOrigin, o, !0);
|
|
174
174
|
return {
|
|
175
175
|
...n,
|
|
176
|
-
stepsToLeaf:
|
|
177
|
-
stepsToOrigin:
|
|
176
|
+
stepsToLeaf: P(r, s, c),
|
|
177
|
+
stepsToOrigin: P(r, l, u),
|
|
178
178
|
nodeVisits: o.visits + s.visits + c.visits + l.visits + u.visits
|
|
179
179
|
};
|
|
180
|
-
},
|
|
181
|
-
let r = Infinity, i =
|
|
180
|
+
}, F = (e, t, n) => {
|
|
181
|
+
let r = Infinity, i = C;
|
|
182
182
|
for (let a of t) {
|
|
183
183
|
let t = e.get(a[n]);
|
|
184
|
-
!t || t[0] ===
|
|
184
|
+
!t || t[0] === S || (r = Math.min(r, t[0] + 1), i = Math.max(i, t[1] + 1));
|
|
185
185
|
}
|
|
186
|
-
return r === Infinity ? [
|
|
187
|
-
},
|
|
186
|
+
return r === Infinity ? [S, S] : [r, i];
|
|
187
|
+
}, ie = (e, t) => {
|
|
188
188
|
let n = e.stepsToLeaf.get(t.id);
|
|
189
189
|
if (n) return [n[0], n[1]];
|
|
190
|
-
let r =
|
|
191
|
-
return r.length === 0 ? [0, 0] :
|
|
192
|
-
},
|
|
190
|
+
let r = b(e, t.id);
|
|
191
|
+
return r.length === 0 ? [0, 0] : F(e.stepsToLeaf, r, "destinationNodeId");
|
|
192
|
+
}, ae = (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] : F(e.stepsToOrigin, x(e, t.id), "sourceNodeId");
|
|
195
|
+
}, I = "conditions.", L = s("condition-results");
|
|
196
|
+
function R(e) {
|
|
197
197
|
return typeof e == "object" && !!e && !Array.isArray(e);
|
|
198
198
|
}
|
|
199
|
-
function
|
|
199
|
+
function z(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) => z(e));
|
|
202
|
+
if (R(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] = z(e[r]);
|
|
205
205
|
return n;
|
|
206
206
|
}
|
|
207
207
|
return e;
|
|
208
208
|
}
|
|
209
|
-
function
|
|
210
|
-
return JSON.stringify(
|
|
209
|
+
function B(e) {
|
|
210
|
+
return JSON.stringify(z(e));
|
|
211
211
|
}
|
|
212
|
-
var
|
|
213
|
-
let e =
|
|
212
|
+
var oe = f(() => {
|
|
213
|
+
let e = L.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 H = f(() => {
|
|
|
247
247
|
reset: i
|
|
248
248
|
};
|
|
249
249
|
});
|
|
250
|
-
function
|
|
251
|
-
return p(
|
|
250
|
+
function V() {
|
|
251
|
+
return p(oe);
|
|
252
252
|
}
|
|
253
|
-
async function
|
|
253
|
+
async function H(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 U(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 W(e) {
|
|
261
|
+
if (Array.isArray(e)) return e.some(W);
|
|
262
|
+
if (R(e)) {
|
|
263
|
+
let t = U(e.var);
|
|
264
|
+
return t !== void 0 && (t === "actions" || t.startsWith("actions.")) ? !0 : Object.values(e).some(W);
|
|
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 G(e) {
|
|
269
|
+
if (Array.isArray(e)) return e.flatMap(G);
|
|
270
|
+
if (R(e)) {
|
|
271
|
+
let t = U(e.var);
|
|
272
|
+
return [...t !== void 0 && t.startsWith(I) ? [t.slice(11)] : [], ...Object.values(e).flatMap(G)];
|
|
273
273
|
}
|
|
274
274
|
return [];
|
|
275
275
|
}
|
|
276
|
-
function
|
|
277
|
-
if (
|
|
278
|
-
for (let r of
|
|
276
|
+
function K(e, t, n = /* @__PURE__ */ new Set()) {
|
|
277
|
+
if (W(e)) return !0;
|
|
278
|
+
for (let r of G(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 && K(e.logic, t, n)) return !0;
|
|
283
283
|
}
|
|
284
284
|
return !1;
|
|
285
285
|
}
|
|
286
|
-
async function
|
|
286
|
+
async function q(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 = K(t, r), a = B(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 H(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 J(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 q(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 Y = (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 ? Y(e, n, !1, r) : [];
|
|
314
|
+
})), se = (e, t) => Y(e, t, !0, /* @__PURE__ */ new Set()), ce = (e) => e.find((e) => e.type === "origin") || null, X = (e, t, n) => {
|
|
315
|
+
if (!e) return ce(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 le(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 ue(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
|
|
333
|
+
var Z = s("experience-instance"), de = /* @__PURE__ */ new WeakMap(), fe = 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(), D = l(), O = l(), k = s.componentStore, te = Z.store("transitioning"), ne = r.history.entriesStore.map((e) => e.filter((e) => e.experienceId === s.id)), A = ne.map((e) => e.filter((e) => h(e.node))), j = ne.map((e) => e.at(-1)?.node || null), M = Z.store(null);
|
|
335
335
|
u({
|
|
336
336
|
clock: [
|
|
337
|
-
|
|
337
|
+
j,
|
|
338
338
|
r.steps.listStore,
|
|
339
|
-
|
|
339
|
+
T
|
|
340
340
|
],
|
|
341
341
|
source: {
|
|
342
342
|
steps: r.steps.listStore,
|
|
343
|
-
node:
|
|
343
|
+
node: j
|
|
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: M
|
|
348
348
|
});
|
|
349
|
-
let
|
|
349
|
+
let N = a(r.steps.listStore, A, (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
|
+
}), P = a(s.nodeTreeStore, j, (e, t) => t ? se(e, t) : []), re = a(s.nodeTreeStore, j, (e, t) => t ? ae(e, t) : [-1, -1]), F = a(s.nodeTreeStore, j, (e, t) => t ? ie(e, t) : [-1, -1]), I = Z.store(!v).on(D, (e, t) => t), L = Z.store(!1), R = o(L, {
|
|
355
355
|
open: () => !0,
|
|
356
356
|
close: () => !1,
|
|
357
357
|
toggle: (e) => !e,
|
|
358
358
|
set: (e, t) => t
|
|
359
|
-
}),
|
|
359
|
+
}), z = c(async () => {
|
|
360
360
|
r.history.back({ experienceId: s.id });
|
|
361
|
-
}),
|
|
361
|
+
}), B = 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 Q = s("experience-instance"), $ = f(({ client: r, experience: s, target: f,
|
|
|
367
367
|
node: n
|
|
368
368
|
});
|
|
369
369
|
}
|
|
370
|
-
}),
|
|
370
|
+
}), oe = i({
|
|
371
371
|
source: s.treeStore,
|
|
372
372
|
effect: async (e, t) => {
|
|
373
373
|
let n = e.steps.find((e) => e.key === t);
|
|
@@ -378,25 +378,25 @@ var Q = s("experience-instance"), $ = f(({ client: r, experience: s, target: f,
|
|
|
378
378
|
node: i
|
|
379
379
|
});
|
|
380
380
|
}
|
|
381
|
-
}),
|
|
382
|
-
source:
|
|
381
|
+
}), V = i({
|
|
382
|
+
source: j,
|
|
383
383
|
effect: (e) => {}
|
|
384
|
-
}),
|
|
384
|
+
}), H = i({
|
|
385
385
|
source: s.treeStore,
|
|
386
|
-
effect: async ({ nodes: e }) =>
|
|
387
|
-
}),
|
|
386
|
+
effect: async ({ nodes: e }) => ce(e)
|
|
387
|
+
}), U = i({
|
|
388
388
|
source: s.treeStore,
|
|
389
389
|
effect: async ({ nodes: e, edges: t }, n) => {
|
|
390
|
-
if (
|
|
390
|
+
if (g(n)) return X(n, e, t);
|
|
391
391
|
}
|
|
392
|
-
}),
|
|
392
|
+
}), W = i({
|
|
393
393
|
source: s.treeStore,
|
|
394
394
|
effect: async ({ nodes: e, edges: n, conditions: i }, a) => {
|
|
395
395
|
if (!m(a)) return;
|
|
396
396
|
let o = i.find((e) => e.id === a.conditionId)?.logic;
|
|
397
|
-
return o ?
|
|
397
|
+
return o ? le(!!await t(r, o), a.id, e, n) : void 0;
|
|
398
398
|
}
|
|
399
|
-
}),
|
|
399
|
+
}), G = i({
|
|
400
400
|
source: {
|
|
401
401
|
tree: s.treeStore,
|
|
402
402
|
actions: r.actions.listStore,
|
|
@@ -404,55 +404,58 @@ var Q = s("experience-instance"), $ = f(({ client: r, experience: s, target: f,
|
|
|
404
404
|
},
|
|
405
405
|
effect: async ({ tree: e, actions: t, snapshot: n }, r) => {
|
|
406
406
|
let { nodes: i, edges: a } = e;
|
|
407
|
-
if (!
|
|
407
|
+
if (!_(r)) return;
|
|
408
408
|
let o = r.actionKey;
|
|
409
409
|
if (!o) {
|
|
410
410
|
`${r.id}`;
|
|
411
411
|
return;
|
|
412
412
|
}
|
|
413
413
|
let s = t.find((e) => e.key === o)?.action;
|
|
414
|
-
if (typeof s != "function") return `${o}`,
|
|
414
|
+
if (typeof s != "function") return `${o}`, ue(!1, r.id, i, a) ?? null;
|
|
415
415
|
let c = !0;
|
|
416
416
|
try {
|
|
417
417
|
`${o}`, await s({
|
|
418
418
|
...n,
|
|
419
419
|
args: []
|
|
420
|
-
}, { experience:
|
|
420
|
+
}, { experience: $ });
|
|
421
421
|
} catch {
|
|
422
422
|
`${o}`, c = !1;
|
|
423
423
|
}
|
|
424
|
-
let l =
|
|
424
|
+
let l = ue(c, r.id, i, a);
|
|
425
425
|
if (!l) {
|
|
426
426
|
let e = a.some((e) => e.sourceNodeId === r.id) ? "no edge for its outcome" : "no outgoing edge";
|
|
427
427
|
return `${r.id}${e}`, null;
|
|
428
428
|
}
|
|
429
429
|
return `${o}${l.id}`, l;
|
|
430
430
|
}
|
|
431
|
-
}), U = c((e) => {
|
|
432
|
-
g(e) && r.experiences.launch({ key: e.experienceKey });
|
|
433
|
-
}), W = i({
|
|
434
|
-
source: [A, s.treeStore],
|
|
435
|
-
effect: async ([e, { nodes: t, edges: n }]) => Z(e, t, n)
|
|
436
|
-
}), G = i({
|
|
437
|
-
source: [A, s.treeStore],
|
|
438
|
-
effect: async ([e, { nodes: t, edges: n }]) => Z(e, t, n)
|
|
439
431
|
}), K = c((e) => {
|
|
440
|
-
r.
|
|
441
|
-
experienceId: s.id,
|
|
442
|
-
node: e
|
|
443
|
-
});
|
|
432
|
+
ee(e) && r.experiences.launch({ key: e.experienceKey });
|
|
444
433
|
}), q = i({
|
|
434
|
+
source: [j, s.treeStore],
|
|
435
|
+
effect: async ([e, { nodes: t, edges: n }]) => X(e, t, n)
|
|
436
|
+
}), J = i({
|
|
437
|
+
source: [j, s.treeStore],
|
|
438
|
+
effect: async ([e, { nodes: t, edges: n }]) => X(e, t, n)
|
|
439
|
+
}), Y = i({
|
|
440
|
+
source: I,
|
|
441
|
+
effect: (e, t) => {
|
|
442
|
+
e && r.history.push({
|
|
443
|
+
experienceId: s.id,
|
|
444
|
+
node: t
|
|
445
|
+
});
|
|
446
|
+
}
|
|
447
|
+
}), fe = i({
|
|
445
448
|
source: s.configStore,
|
|
446
|
-
effect: async ({ initializeOpenLogic: n }) => p?.initialiseOpen === void 0 ? e(n) ? !!await t(r, n) : n
|
|
447
|
-
}),
|
|
449
|
+
effect: async ({ initializeOpenLogic: n }) => p?.initialiseOpen === void 0 ? n == null ? y === "rendered" : e(n) ? !!await t(r, n) : n : p.initialiseOpen
|
|
450
|
+
}), Q = a(k, r.frameworks.listStore, (e, t) => {
|
|
448
451
|
if (!e) return null;
|
|
449
452
|
let n = t.find((t) => t.name === e.component.frameworkName);
|
|
450
453
|
return n ? {
|
|
451
454
|
component: e,
|
|
452
455
|
framework: n
|
|
453
456
|
} : null;
|
|
454
|
-
}, { skipVoid: !1 }),
|
|
455
|
-
source:
|
|
457
|
+
}, { skipVoid: !1 }), $, pe = i({
|
|
458
|
+
source: Q,
|
|
456
459
|
effect: (e) => {
|
|
457
460
|
if (!e) return;
|
|
458
461
|
if (!f) {
|
|
@@ -461,172 +464,180 @@ var Q = s("experience-instance"), $ = f(({ client: r, experience: s, target: f,
|
|
|
461
464
|
}
|
|
462
465
|
let t = n(f);
|
|
463
466
|
try {
|
|
464
|
-
e.framework.render(t, e.component.component, r,
|
|
467
|
+
e.framework.render(t, e.component.component, r, $);
|
|
465
468
|
} catch {}
|
|
466
469
|
}
|
|
467
470
|
});
|
|
468
|
-
|
|
471
|
+
$ = Object.freeze({
|
|
469
472
|
id: Math.random().toString(36).substring(7),
|
|
470
473
|
experienceKey: s.key,
|
|
471
474
|
experienceId: s.id,
|
|
472
475
|
experienceName: s.name,
|
|
473
476
|
configStore: s.configStore,
|
|
474
477
|
target: f,
|
|
475
|
-
componentStore:
|
|
476
|
-
componentAndFrameworkStore:
|
|
477
|
-
stateStore:
|
|
478
|
-
isOpenStore:
|
|
479
|
-
open:
|
|
480
|
-
close:
|
|
481
|
-
toggleOpen:
|
|
482
|
-
setOpen:
|
|
478
|
+
componentStore: k,
|
|
479
|
+
componentAndFrameworkStore: Q,
|
|
480
|
+
stateStore: te,
|
|
481
|
+
isOpenStore: L,
|
|
482
|
+
open: R.open,
|
|
483
|
+
close: R.close,
|
|
484
|
+
toggleOpen: R.toggle,
|
|
485
|
+
setOpen: R.set,
|
|
483
486
|
treeStore: s.treeStore,
|
|
484
|
-
currentNodeStore:
|
|
485
|
-
currentStepStore:
|
|
486
|
-
previousStepStore:
|
|
487
|
-
nextReachableStepNodesStore:
|
|
488
|
-
stepsToOriginStore:
|
|
489
|
-
stepsToLeafStore:
|
|
490
|
-
goToNextStep:
|
|
491
|
-
goToPreviousStep:
|
|
492
|
-
goToStepById:
|
|
493
|
-
goToStepByKey:
|
|
494
|
-
stepsHistoryStore:
|
|
495
|
-
mountFx:
|
|
487
|
+
currentNodeStore: j,
|
|
488
|
+
currentStepStore: M,
|
|
489
|
+
previousStepStore: N,
|
|
490
|
+
nextReachableStepNodesStore: P,
|
|
491
|
+
stepsToOriginStore: re,
|
|
492
|
+
stepsToLeafStore: F,
|
|
493
|
+
goToNextStep: x,
|
|
494
|
+
goToPreviousStep: S,
|
|
495
|
+
goToStepById: C,
|
|
496
|
+
goToStepByKey: w,
|
|
497
|
+
stepsHistoryStore: A,
|
|
498
|
+
mountFx: pe
|
|
496
499
|
});
|
|
497
|
-
let
|
|
500
|
+
let me = l(), he = l();
|
|
498
501
|
return u({
|
|
499
|
-
clock:
|
|
500
|
-
|
|
502
|
+
clock: j,
|
|
503
|
+
filter: I,
|
|
504
|
+
target: me
|
|
501
505
|
}), u({
|
|
502
|
-
clock:
|
|
506
|
+
clock: me,
|
|
503
507
|
filter: (e) => e === null,
|
|
504
|
-
target:
|
|
508
|
+
target: H
|
|
505
509
|
}), u({
|
|
506
|
-
clock:
|
|
510
|
+
clock: me,
|
|
507
511
|
filter: (e) => e !== null,
|
|
508
|
-
target:
|
|
512
|
+
target: he
|
|
509
513
|
}), d({
|
|
510
|
-
source:
|
|
511
|
-
match: (e) => m(e) ? "condition" : h(e) ? "step" :
|
|
514
|
+
source: he,
|
|
515
|
+
match: (e) => m(e) ? "condition" : h(e) ? "step" : ee(e) ? "launchExperience" : g(e) ? "origin" : _(e) ? "action" : "other",
|
|
512
516
|
cases: {
|
|
513
|
-
origin:
|
|
514
|
-
condition:
|
|
515
|
-
step:
|
|
516
|
-
launchExperience:
|
|
517
|
-
action:
|
|
517
|
+
origin: U,
|
|
518
|
+
condition: W,
|
|
519
|
+
step: V,
|
|
520
|
+
launchExperience: K,
|
|
521
|
+
action: G,
|
|
518
522
|
__: l()
|
|
519
523
|
}
|
|
520
524
|
}), u({
|
|
521
525
|
clock: [
|
|
522
|
-
V.doneData,
|
|
523
|
-
B.doneData,
|
|
524
|
-
z.doneData,
|
|
525
|
-
G.doneData,
|
|
526
526
|
W.doneData,
|
|
527
|
-
|
|
527
|
+
U.doneData,
|
|
528
|
+
H.doneData,
|
|
529
|
+
J.doneData,
|
|
530
|
+
q.doneData,
|
|
531
|
+
G.doneData
|
|
528
532
|
],
|
|
529
533
|
filter: Boolean,
|
|
530
|
-
target:
|
|
534
|
+
target: Y
|
|
531
535
|
}), u({
|
|
532
|
-
clock:
|
|
533
|
-
target:
|
|
536
|
+
clock: x,
|
|
537
|
+
target: J
|
|
534
538
|
}), u({
|
|
535
|
-
clock:
|
|
536
|
-
source:
|
|
539
|
+
clock: x,
|
|
540
|
+
source: M,
|
|
537
541
|
filter: Boolean,
|
|
538
|
-
target:
|
|
542
|
+
target: O.prepend((e) => ({
|
|
539
543
|
type: "step_submit",
|
|
540
544
|
step: e,
|
|
541
|
-
experience:
|
|
545
|
+
experience: $
|
|
542
546
|
}))
|
|
543
547
|
}), u({
|
|
544
|
-
clock:
|
|
545
|
-
source:
|
|
548
|
+
clock: J.done,
|
|
549
|
+
source: M,
|
|
546
550
|
filter: Boolean,
|
|
547
|
-
target:
|
|
551
|
+
target: O.prepend((e) => ({
|
|
548
552
|
type: "step_submit_success",
|
|
549
553
|
step: e,
|
|
550
|
-
experience:
|
|
554
|
+
experience: $
|
|
551
555
|
}))
|
|
552
556
|
}), u({
|
|
553
|
-
clock:
|
|
554
|
-
source:
|
|
557
|
+
clock: J.fail,
|
|
558
|
+
source: M,
|
|
555
559
|
filter: Boolean,
|
|
556
|
-
target:
|
|
560
|
+
target: O.prepend((e) => ({
|
|
557
561
|
type: "step_submit_error",
|
|
558
562
|
step: e,
|
|
559
|
-
experience:
|
|
563
|
+
experience: $
|
|
560
564
|
}))
|
|
561
|
-
}), u({
|
|
562
|
-
clock: x,
|
|
563
|
-
target: te
|
|
564
565
|
}), u({
|
|
565
566
|
clock: S,
|
|
566
|
-
target:
|
|
567
|
+
target: z
|
|
567
568
|
}), u({
|
|
568
569
|
clock: C,
|
|
569
|
-
target:
|
|
570
|
+
target: B
|
|
571
|
+
}), u({
|
|
572
|
+
clock: w,
|
|
573
|
+
target: oe
|
|
570
574
|
}), u({
|
|
571
575
|
source: a([
|
|
572
|
-
V.pending,
|
|
573
|
-
B.pending,
|
|
574
|
-
z.pending,
|
|
575
|
-
G.pending,
|
|
576
576
|
W.pending,
|
|
577
|
-
|
|
577
|
+
U.pending,
|
|
578
|
+
H.pending,
|
|
579
|
+
J.pending,
|
|
580
|
+
q.pending,
|
|
581
|
+
G.pending
|
|
578
582
|
]),
|
|
579
583
|
fn: (e) => e.some(Boolean) ? "transitioning" : "ready",
|
|
580
|
-
target:
|
|
584
|
+
target: te
|
|
581
585
|
}), u({
|
|
582
|
-
clock:
|
|
583
|
-
source:
|
|
586
|
+
clock: V.doneData,
|
|
587
|
+
source: M,
|
|
584
588
|
filter: Boolean,
|
|
585
|
-
target:
|
|
589
|
+
target: O.prepend((e) => ({
|
|
586
590
|
type: "step_enter",
|
|
587
591
|
step: e,
|
|
588
|
-
experience:
|
|
592
|
+
experience: $
|
|
589
593
|
}))
|
|
590
594
|
}), u({
|
|
591
|
-
clock:
|
|
592
|
-
target:
|
|
595
|
+
clock: E,
|
|
596
|
+
target: fe
|
|
593
597
|
}), u({
|
|
594
|
-
|
|
598
|
+
clock: fe.doneData,
|
|
599
|
+
filter: I,
|
|
595
600
|
fn: Boolean,
|
|
596
|
-
target:
|
|
601
|
+
target: L
|
|
597
602
|
}), u({
|
|
598
|
-
source:
|
|
599
|
-
clock:
|
|
600
|
-
filter: (e) => !e ||
|
|
601
|
-
target:
|
|
603
|
+
source: j,
|
|
604
|
+
clock: b,
|
|
605
|
+
filter: (e) => !e || g(e),
|
|
606
|
+
target: q
|
|
602
607
|
}), u({
|
|
603
|
-
source:
|
|
608
|
+
source: L,
|
|
604
609
|
filter: Boolean,
|
|
605
|
-
target:
|
|
610
|
+
target: b
|
|
606
611
|
}), u({
|
|
607
|
-
source:
|
|
612
|
+
source: L,
|
|
608
613
|
filter: Boolean,
|
|
609
|
-
target:
|
|
614
|
+
target: O.prepend(() => ({
|
|
610
615
|
type: "experience_open",
|
|
611
|
-
experience:
|
|
616
|
+
experience: $
|
|
612
617
|
}))
|
|
613
618
|
}), u({
|
|
614
|
-
source:
|
|
619
|
+
source: L,
|
|
615
620
|
filter: (e) => !e,
|
|
616
|
-
target:
|
|
621
|
+
target: O.prepend(() => ({
|
|
617
622
|
type: "experience_close",
|
|
618
|
-
experience:
|
|
623
|
+
experience: $
|
|
619
624
|
}))
|
|
620
625
|
}), u({
|
|
621
|
-
clock:
|
|
622
|
-
|
|
623
|
-
|
|
626
|
+
clock: O,
|
|
627
|
+
filter: I,
|
|
628
|
+
target: r.eventBus
|
|
629
|
+
}), v ? de.set($, (e) => {
|
|
630
|
+
e && R.close(), D(e), e && E();
|
|
631
|
+
}) : u({
|
|
632
|
+
clock: T,
|
|
633
|
+
target: E
|
|
634
|
+
}), T(), $;
|
|
624
635
|
});
|
|
625
|
-
function
|
|
626
|
-
return p(
|
|
636
|
+
function Q(e) {
|
|
637
|
+
return p(fe, e);
|
|
627
638
|
}
|
|
628
|
-
var
|
|
629
|
-
let t =
|
|
639
|
+
var $ = f(({ client: e }) => {
|
|
640
|
+
let t = Z.store({}), n = l(), i = l(), a = l(), s = o(t, {
|
|
630
641
|
register(e, t) {
|
|
631
642
|
let n = [...e[t.experienceId] ?? []];
|
|
632
643
|
return n.push(t), {
|
|
@@ -641,7 +652,7 @@ var de = f(({ client: e }) => {
|
|
|
641
652
|
[n]: r ?? []
|
|
642
653
|
};
|
|
643
654
|
}
|
|
644
|
-
}), d = c(({ experience: t, target: n, options: r }) =>
|
|
655
|
+
}), d = c(({ experience: t, target: n, options: r }) => Q({
|
|
645
656
|
client: e,
|
|
646
657
|
experience: t,
|
|
647
658
|
target: n,
|
|
@@ -680,29 +691,44 @@ var de = f(({ client: e }) => {
|
|
|
680
691
|
clock: i,
|
|
681
692
|
target: h
|
|
682
693
|
});
|
|
683
|
-
function
|
|
694
|
+
function ee(e, t, r) {
|
|
684
695
|
n({
|
|
685
696
|
experience: e,
|
|
686
697
|
target: t,
|
|
687
698
|
options: r
|
|
688
699
|
});
|
|
689
700
|
}
|
|
690
|
-
let
|
|
691
|
-
function
|
|
692
|
-
return
|
|
701
|
+
let g = t.map((e) => Object.values(e).flat());
|
|
702
|
+
function _(e) {
|
|
703
|
+
return g.map((t) => t.filter((t) => t.experienceKey === e), { skipVoid: !1 });
|
|
693
704
|
}
|
|
694
|
-
function
|
|
705
|
+
function v(e) {
|
|
695
706
|
return t.map((t) => t[e] || [], { skipVoid: !1 });
|
|
696
707
|
}
|
|
708
|
+
let y = /* @__PURE__ */ new Map();
|
|
709
|
+
function b(t) {
|
|
710
|
+
return y.has(t) || (s.register(t), e.eventBus({
|
|
711
|
+
type: "experience_initialize",
|
|
712
|
+
experience: t
|
|
713
|
+
}), de.get(t)?.(!0)), y.set(t, !0), () => {
|
|
714
|
+
y.has(t) && (y.set(t, !1), queueMicrotask(() => {
|
|
715
|
+
y.get(t) === !1 && (y.delete(t), de.get(t)?.(!1), s.unregister(t), e.eventBus({
|
|
716
|
+
type: "experience_unmount",
|
|
717
|
+
experience: t
|
|
718
|
+
}));
|
|
719
|
+
}));
|
|
720
|
+
};
|
|
721
|
+
}
|
|
697
722
|
return {
|
|
698
|
-
spawn:
|
|
699
|
-
|
|
700
|
-
|
|
701
|
-
|
|
723
|
+
spawn: ee,
|
|
724
|
+
adopt: b,
|
|
725
|
+
getByExperienceKey: _,
|
|
726
|
+
getByExperienceId: v,
|
|
727
|
+
listStore: g
|
|
702
728
|
};
|
|
703
729
|
});
|
|
704
|
-
function
|
|
705
|
-
return p(
|
|
730
|
+
function pe(e) {
|
|
731
|
+
return p($, e);
|
|
706
732
|
}
|
|
707
733
|
//#endregion
|
|
708
|
-
export {
|
|
734
|
+
export { B as a, K as c, h as d, q as i, re as l, pe as n, J as o, V as r, W as s, Q as t, m as u };
|