@niscorp/nova 0.1.0 → 0.1.1
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/CHANGELOG.md +7 -0
- package/dist/adapters/react/components/index.d.cts +2 -2
- package/dist/adapters/react/components/index.d.ts +2 -2
- package/dist/adapters/vue/components/index.d.cts +1 -1
- package/dist/adapters/vue/components/index.d.ts +1 -1
- package/package.json +5 -8
- package/dist/chunk-EG2RUXJN.js +0 -266
- package/dist/chunk-EG2RUXJN.js.map +0 -1
- package/dist/chunk-I5D2R5UA.js +0 -753
- package/dist/chunk-I5D2R5UA.js.map +0 -1
- package/dist/chunk-LA3BSEMX.js +0 -1905
- package/dist/chunk-LA3BSEMX.js.map +0 -1
- package/dist/primitive-props-CGoJvmcH.d.cts +0 -100
- package/dist/primitive-props-CGoJvmcH.d.ts +0 -100
package/dist/chunk-LA3BSEMX.js
DELETED
|
@@ -1,1905 +0,0 @@
|
|
|
1
|
-
import { mountInputKeys, composeAction, isMutationStep } from './chunk-RQB4PRPV.js';
|
|
2
|
-
import { ActionDefinitionSchema, ActionFragmentSchema, StepSchema, applyMutations } from './chunk-GVBBL36G.js';
|
|
3
|
-
import { createEventBus } from './chunk-ZITHBBF3.js';
|
|
4
|
-
import { createLayoutStore, renderLayoutFromStore, resolve, createScopeChain } from './chunk-V32EVEVM.js';
|
|
5
|
-
import { UnknownFragmentError, DefinitionValidationError, UnknownActionError, NovaError, ErrorCodes, ShellDisposedError, LifecycleError, UnknownFunctionError, setPath } from './chunk-PF4OJTYU.js';
|
|
6
|
-
import { isArray, isObject, hasKey } from './chunk-RBU5PHN4.js';
|
|
7
|
-
import { createComponentRegistry } from './chunk-2MNLEL45.js';
|
|
8
|
-
import { z } from 'zod';
|
|
9
|
-
import { exceedsDepth, depthRefusal } from '@niscorp/strata';
|
|
10
|
-
|
|
11
|
-
// src/shared/ids.ts
|
|
12
|
-
var fallbackToken = () => `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
|
|
13
|
-
var getCrypto = () => {
|
|
14
|
-
if (typeof globalThis === "undefined") return void 0;
|
|
15
|
-
const g = globalThis;
|
|
16
|
-
return g.crypto;
|
|
17
|
-
};
|
|
18
|
-
var createIdFactory = (prefix) => {
|
|
19
|
-
const cryptoObj = getCrypto();
|
|
20
|
-
const randomUUID = cryptoObj?.randomUUID;
|
|
21
|
-
if (typeof randomUUID === "function") {
|
|
22
|
-
return () => `${prefix}-${randomUUID.call(cryptoObj)}`;
|
|
23
|
-
}
|
|
24
|
-
return () => `${prefix}-${fallbackToken()}`;
|
|
25
|
-
};
|
|
26
|
-
var MessageEnvelopeSchema = z.object({
|
|
27
|
-
channel: z.string().describe("Channel name the message is published on."),
|
|
28
|
-
from: z.string().optional().describe("Optional sender identifier."),
|
|
29
|
-
to: z.string().optional().describe("Optional direct recipient identifier."),
|
|
30
|
-
payload: z.unknown().optional().describe("Optional message payload.")
|
|
31
|
-
}).strict().describe("A message envelope passed through the message bus.");
|
|
32
|
-
|
|
33
|
-
// src/shared/message-bus/message-bus.ts
|
|
34
|
-
var createMessageBus = () => {
|
|
35
|
-
const handlers = /* @__PURE__ */ new Map();
|
|
36
|
-
const dispatch = (channel, payload, from, cause) => {
|
|
37
|
-
const list = handlers.get(channel);
|
|
38
|
-
if (list === void 0) return;
|
|
39
|
-
for (const handler of list.slice()) {
|
|
40
|
-
try {
|
|
41
|
-
handler(payload, from, cause);
|
|
42
|
-
} catch {
|
|
43
|
-
}
|
|
44
|
-
}
|
|
45
|
-
};
|
|
46
|
-
const publish = (channel, payload, cause) => {
|
|
47
|
-
dispatch(channel, payload, void 0, cause);
|
|
48
|
-
};
|
|
49
|
-
const send = (from, to, payload) => {
|
|
50
|
-
dispatch(to, payload, from);
|
|
51
|
-
};
|
|
52
|
-
const subscribe = (channel, handler) => {
|
|
53
|
-
const list = handlers.get(channel) ?? [];
|
|
54
|
-
list.push(handler);
|
|
55
|
-
handlers.set(channel, list);
|
|
56
|
-
return () => {
|
|
57
|
-
const current = handlers.get(channel);
|
|
58
|
-
if (current === void 0) return;
|
|
59
|
-
const idx = current.indexOf(handler);
|
|
60
|
-
if (idx >= 0) current.splice(idx, 1);
|
|
61
|
-
};
|
|
62
|
-
};
|
|
63
|
-
return { publish, send, subscribe };
|
|
64
|
-
};
|
|
65
|
-
|
|
66
|
-
// src/shell/slot-names.ts
|
|
67
|
-
var CANVAS_SLOT_NAME = "CanvasSlot";
|
|
68
|
-
var ACTION_SLOT_NAME = "ActionSlot";
|
|
69
|
-
|
|
70
|
-
// src/shell/reconcile.ts
|
|
71
|
-
var differs = (before, input) => Object.entries(input).some(([key, value]) => JSON.stringify(before[key]) !== JSON.stringify(value));
|
|
72
|
-
var reconcileCanvas = (shell, canvasId, desired, options) => {
|
|
73
|
-
const { origin, definitionOf } = options;
|
|
74
|
-
const ownsCanvas = options.own === "canvas";
|
|
75
|
-
const notes = [];
|
|
76
|
-
let changed = false;
|
|
77
|
-
if (shell.getState().canvases[canvasId] === void 0) return { changed: false, notes: [`no canvas "${canvasId}"`] };
|
|
78
|
-
const wanted = [];
|
|
79
|
-
for (const entry of desired) if (!wanted.some((other) => other.actionId === entry.actionId)) wanted.push(entry);
|
|
80
|
-
const mine = (shell.getState().canvases[canvasId]?.stack ?? []).filter((item) => ownsCanvas || shell.originOf(item.id) === origin);
|
|
81
|
-
for (const item of mine) {
|
|
82
|
-
if (wanted.some((entry) => entry.actionId === item.definitionId)) continue;
|
|
83
|
-
shell.removeInstance(canvasId, item.id);
|
|
84
|
-
changed = true;
|
|
85
|
-
notes.push(`closed ${item.definitionId}`);
|
|
86
|
-
}
|
|
87
|
-
for (const entry of wanted) {
|
|
88
|
-
const input = entry.input ?? {};
|
|
89
|
-
const existing = (shell.getState().canvases[canvasId]?.stack ?? []).find((item) => item.definitionId === entry.actionId);
|
|
90
|
-
if (existing !== void 0 && !ownsCanvas && shell.originOf(existing.id) !== origin) {
|
|
91
|
-
notes.push(`left ${entry.actionId}: not mine`);
|
|
92
|
-
continue;
|
|
93
|
-
}
|
|
94
|
-
if (existing !== void 0) {
|
|
95
|
-
const runtime = shell.getRuntime(existing.id);
|
|
96
|
-
const before = runtime?.getData() ?? {};
|
|
97
|
-
if (runtime === void 0 || Object.keys(input).length === 0 || !differs(before, input)) continue;
|
|
98
|
-
const definition = definitionOf?.(entry.actionId);
|
|
99
|
-
const reAims = definition !== void 0 && Object.keys(input).some((key) => mountInputKeys(definition).has(key));
|
|
100
|
-
if (!reAims) {
|
|
101
|
-
runtime.setData({ ...before, ...input });
|
|
102
|
-
changed = true;
|
|
103
|
-
notes.push(`set ${Object.keys(input).join(", ")} on ${entry.actionId}`);
|
|
104
|
-
continue;
|
|
105
|
-
}
|
|
106
|
-
shell.removeInstance(canvasId, existing.id);
|
|
107
|
-
notes.push(`re-opened ${entry.actionId}`);
|
|
108
|
-
}
|
|
109
|
-
shell.push(canvasId, entry.actionId, input, entry.with, { origin });
|
|
110
|
-
changed = true;
|
|
111
|
-
notes.push(`placed ${entry.actionId}`);
|
|
112
|
-
}
|
|
113
|
-
return { changed, notes };
|
|
114
|
-
};
|
|
115
|
-
|
|
116
|
-
// src/shell/journal.ts
|
|
117
|
-
var DEFAULT_HISTORY_DEPTH = 50;
|
|
118
|
-
var createJournal = (limit) => {
|
|
119
|
-
const entries = [];
|
|
120
|
-
let mutes = 0;
|
|
121
|
-
const off = () => limit <= 0 || mutes > 0;
|
|
122
|
-
return {
|
|
123
|
-
record: (canvas, stack) => {
|
|
124
|
-
if (off()) return;
|
|
125
|
-
entries.push({ canvas, stack });
|
|
126
|
-
if (entries.length > limit) entries.shift();
|
|
127
|
-
},
|
|
128
|
-
// A pop somebody performed themselves IS a back. Without this the journal
|
|
129
|
-
// would still hold the entry that pop just satisfied, and the next press of
|
|
130
|
-
// the back button would spend itself restoring a position already on screen
|
|
131
|
-
// — the double-tap that makes a back button feel broken.
|
|
132
|
-
consume: (canvas) => {
|
|
133
|
-
if (off()) return;
|
|
134
|
-
for (let i = entries.length - 1; i >= 0; i -= 1) {
|
|
135
|
-
if (entries[i]?.canvas !== canvas) continue;
|
|
136
|
-
entries.splice(i, 1);
|
|
137
|
-
return;
|
|
138
|
-
}
|
|
139
|
-
},
|
|
140
|
-
take: () => entries.pop(),
|
|
141
|
-
// REVOCATION REACHES THE JOURNAL OR IT IS NOT REVOCATION. An entry naming
|
|
142
|
-
// an action this shell no longer serves would hand it back on the way out —
|
|
143
|
-
// a grant dropped at the front door and returned through the back one.
|
|
144
|
-
forgetAction: (actionId) => {
|
|
145
|
-
for (let i = entries.length - 1; i >= 0; i -= 1) {
|
|
146
|
-
if (entries[i]?.stack.some((frame) => frame.action === actionId) === true) entries.splice(i, 1);
|
|
147
|
-
}
|
|
148
|
-
},
|
|
149
|
-
forgetCanvas: (canvas) => {
|
|
150
|
-
for (let i = entries.length - 1; i >= 0; i -= 1) {
|
|
151
|
-
if (entries[i]?.canvas === canvas) entries.splice(i, 1);
|
|
152
|
-
}
|
|
153
|
-
},
|
|
154
|
-
mute: (fn) => {
|
|
155
|
-
mutes += 1;
|
|
156
|
-
try {
|
|
157
|
-
return fn();
|
|
158
|
-
} finally {
|
|
159
|
-
mutes -= 1;
|
|
160
|
-
}
|
|
161
|
-
},
|
|
162
|
-
depth: () => entries.length
|
|
163
|
-
};
|
|
164
|
-
};
|
|
165
|
-
|
|
166
|
-
// src/shell/navigation.ts
|
|
167
|
-
var navigatedChannel = (canvasId) => `nova:navigated:${canvasId}`;
|
|
168
|
-
var createNavigationHandler = (ops) => {
|
|
169
|
-
return (currentCanvasId, effect) => {
|
|
170
|
-
if ("push" in effect) {
|
|
171
|
-
const target = effect.push.canvas ?? currentCanvasId;
|
|
172
|
-
ops.push(target, effect.push.action, effect.push.input, effect.push.with);
|
|
173
|
-
return;
|
|
174
|
-
}
|
|
175
|
-
if ("pop" in effect) {
|
|
176
|
-
ops.pop(currentCanvasId);
|
|
177
|
-
return;
|
|
178
|
-
}
|
|
179
|
-
if ("replace" in effect) {
|
|
180
|
-
const target = effect.replace.canvas ?? currentCanvasId;
|
|
181
|
-
ops.replace(target, effect.replace.action, effect.replace.input, effect.replace.with);
|
|
182
|
-
return;
|
|
183
|
-
}
|
|
184
|
-
if ("popTo" in effect) {
|
|
185
|
-
ops.popTo(effect.popTo.canvas ?? currentCanvasId, effect.popTo.instance);
|
|
186
|
-
return;
|
|
187
|
-
}
|
|
188
|
-
if ("resetTo" in effect) {
|
|
189
|
-
const target = effect.resetTo.canvas ?? currentCanvasId;
|
|
190
|
-
ops.resetTo(target, effect.resetTo.action, effect.resetTo.input, effect.resetTo.with);
|
|
191
|
-
return;
|
|
192
|
-
}
|
|
193
|
-
if ("removeInstance" in effect) {
|
|
194
|
-
ops.removeInstance(effect.removeInstance.canvas ?? currentCanvasId, effect.removeInstance.instance);
|
|
195
|
-
return;
|
|
196
|
-
}
|
|
197
|
-
if ("reconcile" in effect) {
|
|
198
|
-
const { canvas, desired, origin, own, with: fragments } = effect.reconcile;
|
|
199
|
-
ops.reconcile(canvas ?? currentCanvasId, desired, {
|
|
200
|
-
origin: origin ?? "reconcile",
|
|
201
|
-
...own === void 0 ? {} : { own },
|
|
202
|
-
...fragments === void 0 ? {} : { with: fragments }
|
|
203
|
-
});
|
|
204
|
-
}
|
|
205
|
-
};
|
|
206
|
-
};
|
|
207
|
-
|
|
208
|
-
// src/shared/data-store/data-store.ts
|
|
209
|
-
var createDataStore = (initial) => {
|
|
210
|
-
let current = { ...initial };
|
|
211
|
-
const subscribers = [];
|
|
212
|
-
const get = () => current;
|
|
213
|
-
const update = (updater) => {
|
|
214
|
-
current = updater(current);
|
|
215
|
-
for (const handler of subscribers.slice()) {
|
|
216
|
-
try {
|
|
217
|
-
handler(current);
|
|
218
|
-
} catch {
|
|
219
|
-
}
|
|
220
|
-
}
|
|
221
|
-
};
|
|
222
|
-
const subscribe = (handler) => {
|
|
223
|
-
subscribers.push(handler);
|
|
224
|
-
return () => {
|
|
225
|
-
const idx = subscribers.indexOf(handler);
|
|
226
|
-
if (idx >= 0) subscribers.splice(idx, 1);
|
|
227
|
-
};
|
|
228
|
-
};
|
|
229
|
-
return { get, update, subscribe };
|
|
230
|
-
};
|
|
231
|
-
|
|
232
|
-
// src/action/runtime/endpoints.ts
|
|
233
|
-
var stringifyForBody = (value) => {
|
|
234
|
-
if (typeof value === "string") return value;
|
|
235
|
-
try {
|
|
236
|
-
return JSON.stringify(value);
|
|
237
|
-
} catch {
|
|
238
|
-
return void 0;
|
|
239
|
-
}
|
|
240
|
-
};
|
|
241
|
-
var resolveHeaders = (headers, chain) => {
|
|
242
|
-
if (headers === void 0) return void 0;
|
|
243
|
-
const out = {};
|
|
244
|
-
for (const key of Object.keys(headers)) {
|
|
245
|
-
const value = resolve(headers[key], chain);
|
|
246
|
-
out[key] = typeof value === "string" ? value : String(value ?? "");
|
|
247
|
-
}
|
|
248
|
-
return out;
|
|
249
|
-
};
|
|
250
|
-
var defaultFetch = () => {
|
|
251
|
-
throw new Error("No fetch implementation provided to action runtime");
|
|
252
|
-
};
|
|
253
|
-
var tryParseJson = async (response) => {
|
|
254
|
-
try {
|
|
255
|
-
return await response.json();
|
|
256
|
-
} catch {
|
|
257
|
-
try {
|
|
258
|
-
return await response.text();
|
|
259
|
-
} catch {
|
|
260
|
-
return void 0;
|
|
261
|
-
}
|
|
262
|
-
}
|
|
263
|
-
};
|
|
264
|
-
var DEFAULT_ENDPOINT_TIMEOUT_MS = 3e4;
|
|
265
|
-
var callEndpoint = async (options) => {
|
|
266
|
-
const wait = options.endpoint.timeoutMs ?? options.timeoutMs ?? DEFAULT_ENDPOINT_TIMEOUT_MS;
|
|
267
|
-
const expiry = new AbortController();
|
|
268
|
-
const signal = options.signal === void 0 ? expiry.signal : AbortSignal.any([options.signal, expiry.signal]);
|
|
269
|
-
const called = { ...options, signal };
|
|
270
|
-
let timer;
|
|
271
|
-
const expired = new Promise((settle) => {
|
|
272
|
-
timer = setTimeout(() => {
|
|
273
|
-
settle({ ok: false, error: { status: 0, message: `no reply within ${wait}ms`, data: void 0, timedOut: true } });
|
|
274
|
-
expiry.abort();
|
|
275
|
-
}, wait);
|
|
276
|
-
});
|
|
277
|
-
try {
|
|
278
|
-
const call = "fn" in options.endpoint ? callFunctionEndpoint(options.endpoint, called) : callHttpEndpoint(options.endpoint, called);
|
|
279
|
-
return await Promise.race([call, expired]);
|
|
280
|
-
} finally {
|
|
281
|
-
clearTimeout(timer);
|
|
282
|
-
}
|
|
283
|
-
};
|
|
284
|
-
var callHttpEndpoint = async (endpoint, { data, fetch: fetchFn = defaultFetch, transform, signal }) => {
|
|
285
|
-
const chain = createScopeChain(data);
|
|
286
|
-
const resolvedUrl = resolve(endpoint.url, chain);
|
|
287
|
-
const url = typeof resolvedUrl === "string" ? resolvedUrl : String(resolvedUrl ?? "");
|
|
288
|
-
const headers = resolveHeaders(endpoint.headers, chain);
|
|
289
|
-
let body;
|
|
290
|
-
if (endpoint.request !== void 0) {
|
|
291
|
-
if (transform === void 0) {
|
|
292
|
-
return { ok: false, error: { status: 0, message: "endpoint declares `request` but no transform was injected into the shell", data: void 0 } };
|
|
293
|
-
}
|
|
294
|
-
try {
|
|
295
|
-
body = stringifyForBody(transform(endpoint.request, data));
|
|
296
|
-
} catch (err) {
|
|
297
|
-
const message = err instanceof Error ? err.message : "request transform failed";
|
|
298
|
-
return { ok: false, error: { status: 0, message, data: void 0 } };
|
|
299
|
-
}
|
|
300
|
-
}
|
|
301
|
-
let response;
|
|
302
|
-
try {
|
|
303
|
-
response = await fetchFn(url, {
|
|
304
|
-
method: endpoint.method,
|
|
305
|
-
...headers === void 0 ? {} : { headers },
|
|
306
|
-
...body === void 0 ? {} : { body },
|
|
307
|
-
...signal === void 0 ? {} : { signal }
|
|
308
|
-
});
|
|
309
|
-
} catch (err) {
|
|
310
|
-
const isAbort = err instanceof Error && err.name === "AbortError";
|
|
311
|
-
const message = err instanceof Error ? err.message : "fetch failed";
|
|
312
|
-
if (isAbort) return { ok: false, error: { status: 0, message, data: void 0, aborted: true } };
|
|
313
|
-
return { ok: false, error: { status: 0, message, data: void 0 } };
|
|
314
|
-
}
|
|
315
|
-
if (!response.ok) {
|
|
316
|
-
const failed = await tryParseJson(response);
|
|
317
|
-
const message = hasKey(failed, "message") && typeof failed["message"] === "string" ? failed["message"] : `HTTP ${response.status}`;
|
|
318
|
-
return { ok: false, error: { status: response.status, message, data: failed } };
|
|
319
|
-
}
|
|
320
|
-
if (response.status === 204 || response.status === 205) {
|
|
321
|
-
return { ok: true, data: void 0, status: response.status };
|
|
322
|
-
}
|
|
323
|
-
let payload;
|
|
324
|
-
try {
|
|
325
|
-
payload = await response.json();
|
|
326
|
-
} catch {
|
|
327
|
-
return { ok: false, error: { status: response.status, message: `the reply is not JSON (HTTP ${response.status})`, data: void 0 } };
|
|
328
|
-
}
|
|
329
|
-
let result = payload;
|
|
330
|
-
if (endpoint.response !== void 0) {
|
|
331
|
-
if (transform === void 0) {
|
|
332
|
-
return { ok: false, error: { status: response.status, message: "endpoint declares `response` but no transform was injected into the shell", data: payload } };
|
|
333
|
-
}
|
|
334
|
-
try {
|
|
335
|
-
result = transform(endpoint.response, payload);
|
|
336
|
-
} catch (err) {
|
|
337
|
-
const message = err instanceof Error ? err.message : "response transform failed";
|
|
338
|
-
return { ok: false, error: { status: response.status, message, data: payload } };
|
|
339
|
-
}
|
|
340
|
-
}
|
|
341
|
-
const onChange = laterBodiesOf(response, endpoint.response, transform);
|
|
342
|
-
return { ok: true, data: result, status: response.status, ...onChange === void 0 ? {} : { onChange } };
|
|
343
|
-
};
|
|
344
|
-
var laterBodiesOf = (response, config, transform) => {
|
|
345
|
-
const subscribe = response.onChange;
|
|
346
|
-
if (subscribe === void 0) return void 0;
|
|
347
|
-
if (config !== void 0 && transform === void 0) return void 0;
|
|
348
|
-
return (handler) => subscribe((body) => {
|
|
349
|
-
if (config === void 0 || transform === void 0) {
|
|
350
|
-
handler(body);
|
|
351
|
-
return;
|
|
352
|
-
}
|
|
353
|
-
let shaped;
|
|
354
|
-
try {
|
|
355
|
-
shaped = transform(config, body);
|
|
356
|
-
} catch {
|
|
357
|
-
return;
|
|
358
|
-
}
|
|
359
|
-
handler(shaped);
|
|
360
|
-
});
|
|
361
|
-
};
|
|
362
|
-
var callFunctionEndpoint = async (endpoint, { data, signal, functions }) => {
|
|
363
|
-
if (signal === void 0) {
|
|
364
|
-
throw new Error("callEndpoint: function variant requires an AbortSignal");
|
|
365
|
-
}
|
|
366
|
-
const handler = functions?.[endpoint.fn];
|
|
367
|
-
if (handler === void 0) {
|
|
368
|
-
throw new Error(`callEndpoint: function "${endpoint.fn}" is not registered`);
|
|
369
|
-
}
|
|
370
|
-
try {
|
|
371
|
-
const result = await handler(data, signal);
|
|
372
|
-
if (signal.aborted) {
|
|
373
|
-
return {
|
|
374
|
-
ok: false,
|
|
375
|
-
error: { status: 0, message: "aborted", data: void 0, aborted: true }
|
|
376
|
-
};
|
|
377
|
-
}
|
|
378
|
-
return { ok: true, data: result, status: 0 };
|
|
379
|
-
} catch (err) {
|
|
380
|
-
const isAbort = err instanceof Error && err.name === "AbortError";
|
|
381
|
-
const message = err instanceof Error ? err.message : "function failed";
|
|
382
|
-
if (isAbort) {
|
|
383
|
-
return { ok: false, error: { status: 0, message, data: void 0, aborted: true } };
|
|
384
|
-
}
|
|
385
|
-
return { ok: false, error: { status: 0, message, data: void 0 } };
|
|
386
|
-
}
|
|
387
|
-
};
|
|
388
|
-
|
|
389
|
-
// src/action/runtime/cause.ts
|
|
390
|
-
var CAUSE_DEPTH_LIMIT = 64;
|
|
391
|
-
var CAUSE_HOPS_LIMIT = 1024;
|
|
392
|
-
var minted = /* @__PURE__ */ new WeakSet();
|
|
393
|
-
var mint = (cause) => {
|
|
394
|
-
minted.add(cause);
|
|
395
|
-
return cause;
|
|
396
|
-
};
|
|
397
|
-
var isMinted = (value) => minted.has(value);
|
|
398
|
-
var rootCause = () => mint({ depth: 0, root: { hops: 0 } });
|
|
399
|
-
var asCause = (value) => typeof value === "object" && value !== null && isMinted(value) ? value : void 0;
|
|
400
|
-
var nextCause = (parent) => {
|
|
401
|
-
if (parent === void 0) return rootCause();
|
|
402
|
-
parent.root.hops += 1;
|
|
403
|
-
return mint({ depth: parent.depth + 1, root: parent.root });
|
|
404
|
-
};
|
|
405
|
-
var isRunaway = (cause) => cause.depth > CAUSE_DEPTH_LIMIT || cause.root.hops > CAUSE_HOPS_LIMIT;
|
|
406
|
-
var runawayMessage = (cause, what) => `${what} stopped: its chain ran ${cause.depth} hops deep and ${cause.root.hops} hops in total from the gesture that started it (limits ${CAUSE_DEPTH_LIMIT} and ${CAUSE_HOPS_LIMIT}). A trigger that re-emits its own channel, or a mount that reloads itself, never ends.`;
|
|
407
|
-
var ambient;
|
|
408
|
-
var withCause = (cause, run) => {
|
|
409
|
-
const before = ambient;
|
|
410
|
-
ambient = cause;
|
|
411
|
-
try {
|
|
412
|
-
return run();
|
|
413
|
-
} finally {
|
|
414
|
-
ambient = before;
|
|
415
|
-
}
|
|
416
|
-
};
|
|
417
|
-
var ambientCause = () => ambient;
|
|
418
|
-
|
|
419
|
-
// src/action/runtime/next-task.ts
|
|
420
|
-
var viaChannel = () => {
|
|
421
|
-
const queue = [];
|
|
422
|
-
const channel = new MessageChannel();
|
|
423
|
-
channel.port1.onmessage = () => {
|
|
424
|
-
queue.shift()?.();
|
|
425
|
-
};
|
|
426
|
-
return (task) => {
|
|
427
|
-
queue.push(task);
|
|
428
|
-
channel.port2.postMessage(null);
|
|
429
|
-
};
|
|
430
|
-
};
|
|
431
|
-
var pick = () => {
|
|
432
|
-
const host = globalThis;
|
|
433
|
-
if ("setImmediate" in host && typeof host.setImmediate === "function") {
|
|
434
|
-
const immediate = host.setImmediate;
|
|
435
|
-
return (task) => void immediate(task);
|
|
436
|
-
}
|
|
437
|
-
if (typeof MessageChannel === "function") return viaChannel();
|
|
438
|
-
return (task) => void setTimeout(task, 0);
|
|
439
|
-
};
|
|
440
|
-
var scheduler;
|
|
441
|
-
var nextTask = (task) => {
|
|
442
|
-
scheduler ??= pick();
|
|
443
|
-
scheduler(task);
|
|
444
|
-
};
|
|
445
|
-
|
|
446
|
-
// src/action/runtime/steps.ts
|
|
447
|
-
var now = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
|
|
448
|
-
var noopOnError = (_error) => {
|
|
449
|
-
};
|
|
450
|
-
var resolveMutationValues = (list, chain, extras) => {
|
|
451
|
-
return list.map((m) => {
|
|
452
|
-
if ("set" in m && "value" in m) {
|
|
453
|
-
return { ...m, value: resolve(m.value, chain, extras) };
|
|
454
|
-
}
|
|
455
|
-
if ("push" in m && typeof m.push === "string" && "value" in m) {
|
|
456
|
-
return { ...m, value: resolve(m.value, chain, extras) };
|
|
457
|
-
}
|
|
458
|
-
if ("removeAt" in m && typeof m.index === "string") {
|
|
459
|
-
return { ...m, index: Number(resolve(m.index, chain, extras)) };
|
|
460
|
-
}
|
|
461
|
-
if ("move" in m) {
|
|
462
|
-
return {
|
|
463
|
-
...m,
|
|
464
|
-
from: typeof m.from === "string" ? Number(resolve(m.from, chain, extras)) : m.from,
|
|
465
|
-
to: typeof m.to === "string" ? Number(resolve(m.to, chain, extras)) : m.to
|
|
466
|
-
};
|
|
467
|
-
}
|
|
468
|
-
return m;
|
|
469
|
-
});
|
|
470
|
-
};
|
|
471
|
-
var writeTarget = (dataStore, target, value) => {
|
|
472
|
-
if (target === void 0) return;
|
|
473
|
-
dataStore.update((curr) => {
|
|
474
|
-
const next = setPath(curr, target, value);
|
|
475
|
-
return isObject(next) ? next : curr;
|
|
476
|
-
});
|
|
477
|
-
};
|
|
478
|
-
var raiseUnknown = async (message, onError, ctx, strictError) => {
|
|
479
|
-
if (onError) {
|
|
480
|
-
const errorExtras = {
|
|
481
|
-
...ctx.extras,
|
|
482
|
-
"@error": { message, status: 0 }
|
|
483
|
-
};
|
|
484
|
-
await executeSteps(onError, { ...ctx, extras: errorExtras });
|
|
485
|
-
return;
|
|
486
|
-
}
|
|
487
|
-
if (ctx.lifecycleHook !== void 0) {
|
|
488
|
-
throw new LifecycleError(message, { hook: ctx.lifecycleHook });
|
|
489
|
-
}
|
|
490
|
-
if (ctx.strict && strictError !== void 0) throw strictError;
|
|
491
|
-
};
|
|
492
|
-
var runCall = async (callName, onSuccess, onError, ctx) => {
|
|
493
|
-
const raw = ctx.endpoints[callName];
|
|
494
|
-
if (raw === void 0) {
|
|
495
|
-
await raiseUnknown(`unknown endpoint: ${callName}`, onError, ctx);
|
|
496
|
-
return;
|
|
497
|
-
}
|
|
498
|
-
let endpoint = raw;
|
|
499
|
-
if ("fn" in raw) {
|
|
500
|
-
const chain = createScopeChain(ctx.dataStore.get());
|
|
501
|
-
const fn = String(resolve(raw.fn, chain, ctx.extras) ?? "");
|
|
502
|
-
endpoint = { ...raw, fn };
|
|
503
|
-
if (ctx.functions[fn] === void 0) {
|
|
504
|
-
await raiseUnknown(`unknown function: ${fn}`, onError, ctx, new UnknownFunctionError(fn));
|
|
505
|
-
return;
|
|
506
|
-
}
|
|
507
|
-
}
|
|
508
|
-
const ticket = ctx.calls?.begin(callName);
|
|
509
|
-
const t0 = now();
|
|
510
|
-
const result = await callEndpoint({
|
|
511
|
-
endpoint,
|
|
512
|
-
data: ctx.dataStore.get(),
|
|
513
|
-
fetch: ctx.fetch,
|
|
514
|
-
transform: ctx.transform,
|
|
515
|
-
signal: ctx.signal,
|
|
516
|
-
functions: ctx.functions,
|
|
517
|
-
...ctx.endpointTimeoutMs === void 0 ? {} : { timeoutMs: ctx.endpointTimeoutMs }
|
|
518
|
-
});
|
|
519
|
-
if (ctx.signal.aborted) return;
|
|
520
|
-
if (!result.ok && result.error.aborted === true) return;
|
|
521
|
-
ctx.onEndpoint?.({
|
|
522
|
-
name: callName,
|
|
523
|
-
kind: "fn" in endpoint ? "fn" : "http",
|
|
524
|
-
ok: result.ok,
|
|
525
|
-
status: result.ok ? result.status : result.error.status,
|
|
526
|
-
ms: now() - t0
|
|
527
|
-
});
|
|
528
|
-
if (result.ok) {
|
|
529
|
-
const isCurrent = ticket === void 0 || ctx.calls === void 0 || ctx.calls.land(callName, ticket);
|
|
530
|
-
if (isCurrent) {
|
|
531
|
-
writeTarget(ctx.dataStore, endpoint.target, result.data);
|
|
532
|
-
const { dataStore } = ctx;
|
|
533
|
-
const { target } = endpoint;
|
|
534
|
-
if (result.onChange !== void 0 && ticket !== void 0 && ctx.calls !== void 0) {
|
|
535
|
-
ctx.calls.follow(callName, ticket, result.onChange((data) => writeTarget(dataStore, target, data)));
|
|
536
|
-
}
|
|
537
|
-
}
|
|
538
|
-
if (onSuccess) await executeSteps(onSuccess, ctx);
|
|
539
|
-
return;
|
|
540
|
-
}
|
|
541
|
-
writeTarget(ctx.dataStore, endpoint.errorTarget, result.error);
|
|
542
|
-
if (onError) {
|
|
543
|
-
const errorExtras = { ...ctx.extras, "@error": result.error };
|
|
544
|
-
await executeSteps(onError, { ...ctx, extras: errorExtras });
|
|
545
|
-
return;
|
|
546
|
-
}
|
|
547
|
-
if (ctx.lifecycleHook !== void 0) {
|
|
548
|
-
throw new LifecycleError(`endpoint '${callName}' failed: ${result.error.message}`, {
|
|
549
|
-
hook: ctx.lifecycleHook
|
|
550
|
-
});
|
|
551
|
-
}
|
|
552
|
-
};
|
|
553
|
-
var navigate = (effect, ctx) => {
|
|
554
|
-
const { onNavigate } = ctx;
|
|
555
|
-
if (onNavigate === void 0) return;
|
|
556
|
-
withCause(ctx.cause, () => onNavigate(effect));
|
|
557
|
-
};
|
|
558
|
-
var resolveInputMap = (input, ctx) => {
|
|
559
|
-
const chain = createScopeChain(ctx.dataStore.get());
|
|
560
|
-
return Object.fromEntries(
|
|
561
|
-
Object.entries(input).map(([key, value]) => [key, resolve(value, chain, ctx.extras)])
|
|
562
|
-
);
|
|
563
|
-
};
|
|
564
|
-
var resolveNavTarget = (nav, ctx) => {
|
|
565
|
-
const chain = createScopeChain(ctx.dataStore.get());
|
|
566
|
-
const out = { ...nav, action: String(resolve(nav.action, chain, ctx.extras) ?? "") };
|
|
567
|
-
if (nav.input !== void 0) out.input = resolveInputMap(nav.input, ctx);
|
|
568
|
-
return out;
|
|
569
|
-
};
|
|
570
|
-
var resolveNavInput = (effect, ctx) => {
|
|
571
|
-
if ("push" in effect) return { push: resolveNavTarget(effect.push, ctx) };
|
|
572
|
-
if ("replace" in effect) return { replace: resolveNavTarget(effect.replace, ctx) };
|
|
573
|
-
if ("resetTo" in effect) return { resetTo: resolveNavTarget(effect.resetTo, ctx) };
|
|
574
|
-
if ("popTo" in effect) {
|
|
575
|
-
const chain = createScopeChain(ctx.dataStore.get());
|
|
576
|
-
return { popTo: { ...effect.popTo, instance: String(resolve(effect.popTo.instance, chain, ctx.extras) ?? "") } };
|
|
577
|
-
}
|
|
578
|
-
if ("removeInstance" in effect) {
|
|
579
|
-
const chain = createScopeChain(ctx.dataStore.get());
|
|
580
|
-
return { removeInstance: { ...effect.removeInstance, instance: String(resolve(effect.removeInstance.instance, chain, ctx.extras) ?? "") } };
|
|
581
|
-
}
|
|
582
|
-
return effect;
|
|
583
|
-
};
|
|
584
|
-
var resolveReconcile = (step, ctx) => {
|
|
585
|
-
const { to, action, input, ...rest } = step.reconcile;
|
|
586
|
-
const rows = resolve(to, createScopeChain(ctx.dataStore.get()), ctx.extras);
|
|
587
|
-
const desired = (Array.isArray(rows) ? rows : []).flatMap((row) => {
|
|
588
|
-
if (!isObject(row)) return [];
|
|
589
|
-
const actionId = row[action];
|
|
590
|
-
if (typeof actionId !== "string" || actionId === "") return [];
|
|
591
|
-
const seeded = input === void 0 ? void 0 : row[input];
|
|
592
|
-
return [isObject(seeded) ? { actionId, input: seeded } : { actionId }];
|
|
593
|
-
});
|
|
594
|
-
return { reconcile: { ...rest, desired } };
|
|
595
|
-
};
|
|
596
|
-
var executeSteps = async (steps, ctx) => {
|
|
597
|
-
let buffer = [];
|
|
598
|
-
const flush = () => {
|
|
599
|
-
if (buffer.length === 0) return;
|
|
600
|
-
const list = buffer;
|
|
601
|
-
buffer = [];
|
|
602
|
-
const chain = createScopeChain(ctx.dataStore.get());
|
|
603
|
-
const resolved = resolveMutationValues(list, chain, ctx.extras);
|
|
604
|
-
ctx.dataStore.update((curr) => applyMutations(curr, resolved));
|
|
605
|
-
};
|
|
606
|
-
for (const step of steps) {
|
|
607
|
-
if (ctx.signal.aborted) {
|
|
608
|
-
buffer = [];
|
|
609
|
-
return;
|
|
610
|
-
}
|
|
611
|
-
if (isMutationStep(step)) {
|
|
612
|
-
buffer.push(step);
|
|
613
|
-
continue;
|
|
614
|
-
}
|
|
615
|
-
flush();
|
|
616
|
-
if ("call" in step) {
|
|
617
|
-
await runCall(step.call, step.onSuccess, step.onError, ctx);
|
|
618
|
-
if (ctx.signal.aborted) return;
|
|
619
|
-
continue;
|
|
620
|
-
}
|
|
621
|
-
if ("emit" in step) {
|
|
622
|
-
const data = ctx.dataStore.get();
|
|
623
|
-
const chain = createScopeChain(data);
|
|
624
|
-
const resolvedChannel = resolve(step.emit.channel, chain, ctx.extras);
|
|
625
|
-
const channel = typeof resolvedChannel === "string" ? resolvedChannel : String(resolvedChannel ?? "");
|
|
626
|
-
const payload = step.emit.payload === void 0 ? void 0 : resolve(step.emit.payload, chain, ctx.extras);
|
|
627
|
-
const { messageBus, cause } = ctx;
|
|
628
|
-
nextTask(() => messageBus.publish(channel, payload, cause));
|
|
629
|
-
continue;
|
|
630
|
-
}
|
|
631
|
-
if ("push" in step) {
|
|
632
|
-
navigate(resolveNavInput(step, ctx), ctx);
|
|
633
|
-
continue;
|
|
634
|
-
}
|
|
635
|
-
if ("pop" in step) {
|
|
636
|
-
navigate(step, ctx);
|
|
637
|
-
continue;
|
|
638
|
-
}
|
|
639
|
-
if ("replace" in step) {
|
|
640
|
-
navigate(resolveNavInput(step, ctx), ctx);
|
|
641
|
-
continue;
|
|
642
|
-
}
|
|
643
|
-
if ("popTo" in step) {
|
|
644
|
-
navigate(resolveNavInput(step, ctx), ctx);
|
|
645
|
-
continue;
|
|
646
|
-
}
|
|
647
|
-
if ("resetTo" in step) {
|
|
648
|
-
navigate(resolveNavInput(step, ctx), ctx);
|
|
649
|
-
continue;
|
|
650
|
-
}
|
|
651
|
-
if ("removeInstance" in step) {
|
|
652
|
-
navigate(resolveNavInput(step, ctx), ctx);
|
|
653
|
-
continue;
|
|
654
|
-
}
|
|
655
|
-
if ("reconcile" in step) {
|
|
656
|
-
navigate(resolveReconcile(step, ctx), ctx);
|
|
657
|
-
continue;
|
|
658
|
-
}
|
|
659
|
-
if ("removeSelf" in step) {
|
|
660
|
-
navigate(step, ctx);
|
|
661
|
-
continue;
|
|
662
|
-
}
|
|
663
|
-
if ("reload" in step) {
|
|
664
|
-
await ctx.onReload?.(ctx.cause);
|
|
665
|
-
if (ctx.signal.aborted) return;
|
|
666
|
-
continue;
|
|
667
|
-
}
|
|
668
|
-
}
|
|
669
|
-
flush();
|
|
670
|
-
};
|
|
671
|
-
|
|
672
|
-
// src/action/runtime/lifecycle.ts
|
|
673
|
-
var buildInitialData = (definition, input) => {
|
|
674
|
-
const defaults = definition.data ?? {};
|
|
675
|
-
return structuredClone({ ...defaults, ...input ?? {} });
|
|
676
|
-
};
|
|
677
|
-
var runLifecycleHook = async (hook, definition, buildContext) => {
|
|
678
|
-
const lifecycle = definition.lifecycle;
|
|
679
|
-
if (lifecycle === void 0) return;
|
|
680
|
-
const steps = lifecycle[hook];
|
|
681
|
-
if (steps === void 0 || steps.length === 0) return;
|
|
682
|
-
const ctx = { ...buildContext(), lifecycleHook: hook };
|
|
683
|
-
try {
|
|
684
|
-
await executeSteps(steps, ctx);
|
|
685
|
-
} catch (err) {
|
|
686
|
-
if (!ctx.strict) {
|
|
687
|
-
ctx.onError(
|
|
688
|
-
err instanceof LifecycleError ? err : new LifecycleError(
|
|
689
|
-
err instanceof Error ? err.message : String(err),
|
|
690
|
-
{ hook },
|
|
691
|
-
{ cause: err }
|
|
692
|
-
)
|
|
693
|
-
);
|
|
694
|
-
return;
|
|
695
|
-
}
|
|
696
|
-
if (err instanceof LifecycleError) throw err;
|
|
697
|
-
throw new LifecycleError(
|
|
698
|
-
err instanceof Error ? err.message : String(err),
|
|
699
|
-
{ hook },
|
|
700
|
-
{ cause: err }
|
|
701
|
-
);
|
|
702
|
-
}
|
|
703
|
-
};
|
|
704
|
-
|
|
705
|
-
// src/action/runtime/model-bindings.ts
|
|
706
|
-
var walk = (node, out) => {
|
|
707
|
-
if (node.type === "component") {
|
|
708
|
-
if (node.model !== void 0) {
|
|
709
|
-
out.push({ ref: node.model.ref, path: node.model.path });
|
|
710
|
-
}
|
|
711
|
-
for (const child of node.children) walk(child, out);
|
|
712
|
-
return;
|
|
713
|
-
}
|
|
714
|
-
if (node.type === "fragment") {
|
|
715
|
-
for (const child of node.children) walk(child, out);
|
|
716
|
-
}
|
|
717
|
-
};
|
|
718
|
-
var collectModelBindings = (nodes) => {
|
|
719
|
-
const out = [];
|
|
720
|
-
for (const node of nodes) walk(node, out);
|
|
721
|
-
return out;
|
|
722
|
-
};
|
|
723
|
-
|
|
724
|
-
// src/action/runtime/render.ts
|
|
725
|
-
var isLayoutNode = (value) => {
|
|
726
|
-
if (value === null) return true;
|
|
727
|
-
const t = typeof value;
|
|
728
|
-
if (t === "string" || t === "number" || t === "boolean") return true;
|
|
729
|
-
if (isArray(value)) return true;
|
|
730
|
-
if (isObject(value)) return true;
|
|
731
|
-
return false;
|
|
732
|
-
};
|
|
733
|
-
var renderRuntime = (definition, dataStore, ctx) => {
|
|
734
|
-
const layout = definition.layout;
|
|
735
|
-
if (layout === void 0) return [];
|
|
736
|
-
if (typeof layout === "string") {
|
|
737
|
-
const target = ctx.store.get(layout);
|
|
738
|
-
if (target === void 0) return [];
|
|
739
|
-
return renderLayoutFromStore(target, dataStore, ctx);
|
|
740
|
-
}
|
|
741
|
-
if (!isLayoutNode(layout)) return [];
|
|
742
|
-
return renderLayoutFromStore(layout, dataStore, ctx);
|
|
743
|
-
};
|
|
744
|
-
|
|
745
|
-
// src/action/runtime/triggers.ts
|
|
746
|
-
var eventRef = (event) => {
|
|
747
|
-
if (!hasKey(event, "ref")) return void 0;
|
|
748
|
-
const candidate = event["ref"];
|
|
749
|
-
return typeof candidate === "string" ? candidate : void 0;
|
|
750
|
-
};
|
|
751
|
-
var eventKey = (event) => {
|
|
752
|
-
if (!hasKey(event, "key")) return void 0;
|
|
753
|
-
const candidate = event["key"];
|
|
754
|
-
return typeof candidate === "string" ? candidate : void 0;
|
|
755
|
-
};
|
|
756
|
-
var toNovaError = (err) => {
|
|
757
|
-
if (err instanceof NovaError) return err;
|
|
758
|
-
const message = err instanceof Error ? err.message : String(err);
|
|
759
|
-
return new NovaError(ErrorCodes.lifecycle, message, {}, { cause: err });
|
|
760
|
-
};
|
|
761
|
-
var fireTrigger = (trigger, buildContext, event, cause) => {
|
|
762
|
-
const built = buildContext();
|
|
763
|
-
if (built.signal.aborted) return;
|
|
764
|
-
if (built.suspended === true) return;
|
|
765
|
-
if (isRunaway(cause)) {
|
|
766
|
-
const what = trigger.message === void 0 ? "A trigger" : `The trigger on "${trigger.message}"`;
|
|
767
|
-
built.onError(new NovaError(ErrorCodes.runaway, runawayMessage(cause, what), { channel: trigger.message, depth: cause.depth, hops: cause.root.hops }));
|
|
768
|
-
return;
|
|
769
|
-
}
|
|
770
|
-
const base = { ...built, cause };
|
|
771
|
-
const ctx = event === void 0 ? base : { ...base, extras: { ...base.extras, "@event": event } };
|
|
772
|
-
void executeSteps(trigger.do, ctx).catch((err) => {
|
|
773
|
-
ctx.onError(toNovaError(err));
|
|
774
|
-
});
|
|
775
|
-
};
|
|
776
|
-
var eventOrigin = (event) => {
|
|
777
|
-
if (!hasKey(event, "origin")) return void 0;
|
|
778
|
-
const candidate = event["origin"];
|
|
779
|
-
return typeof candidate === "string" ? candidate : void 0;
|
|
780
|
-
};
|
|
781
|
-
var attachTriggers = (triggers, eventBus, messageBus, buildContext, ownInstanceId) => {
|
|
782
|
-
const unsubscribes = [];
|
|
783
|
-
for (const trigger of triggers) {
|
|
784
|
-
if (trigger.event !== void 0) {
|
|
785
|
-
const expectedRef = trigger.ref;
|
|
786
|
-
const expectedKey = trigger.key;
|
|
787
|
-
const triggerType = trigger.event;
|
|
788
|
-
const off = eventBus.on(triggerType, (event) => {
|
|
789
|
-
const origin = eventOrigin(event);
|
|
790
|
-
if (origin !== void 0 && origin !== ownInstanceId) return;
|
|
791
|
-
if (expectedRef !== void 0 && eventRef(event) !== expectedRef) return;
|
|
792
|
-
if (expectedKey !== void 0 && eventKey(event) !== expectedKey) return;
|
|
793
|
-
fireTrigger(trigger, buildContext, event, rootCause());
|
|
794
|
-
});
|
|
795
|
-
unsubscribes.push(off);
|
|
796
|
-
continue;
|
|
797
|
-
}
|
|
798
|
-
if (trigger.message !== void 0) {
|
|
799
|
-
const off = messageBus.subscribe(trigger.message, (payload, _from, cause) => {
|
|
800
|
-
fireTrigger(trigger, buildContext, { payload }, nextCause(asCause(cause)));
|
|
801
|
-
});
|
|
802
|
-
unsubscribes.push(off);
|
|
803
|
-
}
|
|
804
|
-
}
|
|
805
|
-
const detach = () => {
|
|
806
|
-
for (const off of unsubscribes) off();
|
|
807
|
-
};
|
|
808
|
-
return { detach };
|
|
809
|
-
};
|
|
810
|
-
|
|
811
|
-
// src/action/runtime/runtime.ts
|
|
812
|
-
var defaultInstanceIdFactory = createIdFactory("act");
|
|
813
|
-
var createActionRuntime = (config) => {
|
|
814
|
-
const definition = config.definition;
|
|
815
|
-
const initialData = buildInitialData(definition, config.input);
|
|
816
|
-
const initialSnapshot = structuredClone(initialData);
|
|
817
|
-
const dataStore = createDataStore(initialData);
|
|
818
|
-
const abortController = new AbortController();
|
|
819
|
-
const strict = config.strict ?? false;
|
|
820
|
-
const onError = config.onError ?? noopOnError;
|
|
821
|
-
const instanceIdFn = config.instanceIdFn ?? defaultInstanceIdFactory;
|
|
822
|
-
const instance = {
|
|
823
|
-
id: config.instanceId ?? instanceIdFn(),
|
|
824
|
-
definitionId: definition.id,
|
|
825
|
-
canvasId: config.canvasId ?? "default",
|
|
826
|
-
status: "initializing",
|
|
827
|
-
data: dataStore.get()
|
|
828
|
-
};
|
|
829
|
-
const statusSubscribers = [];
|
|
830
|
-
let triggerHandle;
|
|
831
|
-
let modelWriteOff;
|
|
832
|
-
const modelListeners = /* @__PURE__ */ new Map();
|
|
833
|
-
dataStore.subscribe((next) => {
|
|
834
|
-
instance.data = next;
|
|
835
|
-
});
|
|
836
|
-
const ledger = /* @__PURE__ */ new Map();
|
|
837
|
-
const entryOf = (endpoint) => {
|
|
838
|
-
const existing = ledger.get(endpoint);
|
|
839
|
-
if (existing !== void 0) return existing;
|
|
840
|
-
const created = { issued: 0, landed: 0 };
|
|
841
|
-
ledger.set(endpoint, created);
|
|
842
|
-
return created;
|
|
843
|
-
};
|
|
844
|
-
const calls = {
|
|
845
|
-
begin: (endpoint) => {
|
|
846
|
-
const entry = entryOf(endpoint);
|
|
847
|
-
entry.issued += 1;
|
|
848
|
-
return entry.issued;
|
|
849
|
-
},
|
|
850
|
-
land: (endpoint, ticket) => {
|
|
851
|
-
const entry = entryOf(endpoint);
|
|
852
|
-
if (ticket < entry.landed) return false;
|
|
853
|
-
entry.landed = ticket;
|
|
854
|
-
entry.stop?.();
|
|
855
|
-
delete entry.stop;
|
|
856
|
-
return true;
|
|
857
|
-
},
|
|
858
|
-
follow: (endpoint, ticket, stop) => {
|
|
859
|
-
const entry = entryOf(endpoint);
|
|
860
|
-
if (ticket !== entry.landed || abortController.signal.aborted) {
|
|
861
|
-
stop();
|
|
862
|
-
return;
|
|
863
|
-
}
|
|
864
|
-
entry.stop?.();
|
|
865
|
-
entry.stop = stop;
|
|
866
|
-
}
|
|
867
|
-
};
|
|
868
|
-
const stopFollowing = () => {
|
|
869
|
-
for (const entry of ledger.values()) {
|
|
870
|
-
entry.stop?.();
|
|
871
|
-
delete entry.stop;
|
|
872
|
-
}
|
|
873
|
-
};
|
|
874
|
-
const stamp = (effect) => {
|
|
875
|
-
if ("removeSelf" in effect) return { removeInstance: { instance: instance.id } };
|
|
876
|
-
if ("reconcile" in effect) return { reconcile: { origin: instance.definitionId, ...effect.reconcile } };
|
|
877
|
-
return effect;
|
|
878
|
-
};
|
|
879
|
-
const onNavigate = config.onNavigate === void 0 ? void 0 : (effect) => config.onNavigate(stamp(effect));
|
|
880
|
-
let reloading = false;
|
|
881
|
-
let reloadAgain;
|
|
882
|
-
const reload = async (cause) => {
|
|
883
|
-
if (reloading) {
|
|
884
|
-
reloadAgain = { cause };
|
|
885
|
-
return;
|
|
886
|
-
}
|
|
887
|
-
reloading = true;
|
|
888
|
-
try {
|
|
889
|
-
let next = { cause };
|
|
890
|
-
while (next !== void 0) {
|
|
891
|
-
reloadAgain = void 0;
|
|
892
|
-
const hop = nextCause(next.cause);
|
|
893
|
-
if (isRunaway(hop)) {
|
|
894
|
-
onError(new NovaError(ErrorCodes.runaway, runawayMessage(hop, `Reloading "${definition.id}"`), { depth: hop.depth, hops: hop.root.hops }));
|
|
895
|
-
return;
|
|
896
|
-
}
|
|
897
|
-
await runLifecycleHook("mount", definition, () => buildContext(abortController.signal, hop));
|
|
898
|
-
next = reloadAgain;
|
|
899
|
-
}
|
|
900
|
-
} finally {
|
|
901
|
-
reloading = false;
|
|
902
|
-
reloadAgain = void 0;
|
|
903
|
-
}
|
|
904
|
-
};
|
|
905
|
-
const buildContext = (signal = abortController.signal, cause) => ({
|
|
906
|
-
dataStore,
|
|
907
|
-
endpoints: definition.endpoints ?? {},
|
|
908
|
-
functions: config.functions ?? {},
|
|
909
|
-
...config.endpointTimeoutMs === void 0 ? {} : { endpointTimeoutMs: config.endpointTimeoutMs },
|
|
910
|
-
eventBus: config.eventBus,
|
|
911
|
-
messageBus: config.messageBus,
|
|
912
|
-
...config.fetch === void 0 ? {} : { fetch: config.fetch },
|
|
913
|
-
...config.transform === void 0 ? {} : { transform: config.transform },
|
|
914
|
-
...onNavigate === void 0 ? {} : { onNavigate },
|
|
915
|
-
// Stamp the call event with this instance's identity before it flows up to
|
|
916
|
-
// the shell's telemetry — `runCall` only knows the endpoint, the runtime
|
|
917
|
-
// knows who made it.
|
|
918
|
-
...config.onEndpoint === void 0 ? {} : { onEndpoint: (event) => config.onEndpoint({ ...event, instanceId: instance.id, canvasId: instance.canvasId }) },
|
|
919
|
-
calls,
|
|
920
|
-
extras: {},
|
|
921
|
-
strict,
|
|
922
|
-
onError,
|
|
923
|
-
signal,
|
|
924
|
-
suspended: instance.status === "suspended",
|
|
925
|
-
// `reload` — re-run this instance's own mount hook. The same refresh
|
|
926
|
-
// `resume` performs, made available as a step for canvases that never
|
|
927
|
-
// suspend (a list keeps every card active, so nothing else would ever
|
|
928
|
-
// re-read one).
|
|
929
|
-
onReload: reload,
|
|
930
|
-
...cause === void 0 ? {} : { cause }
|
|
931
|
-
});
|
|
932
|
-
const setStatus = (next) => {
|
|
933
|
-
if (instance.status === next) return;
|
|
934
|
-
instance.status = next;
|
|
935
|
-
for (const handler of statusSubscribers.slice()) {
|
|
936
|
-
try {
|
|
937
|
-
handler(next);
|
|
938
|
-
} catch {
|
|
939
|
-
}
|
|
940
|
-
}
|
|
941
|
-
};
|
|
942
|
-
const attach = () => {
|
|
943
|
-
if (modelWriteOff === void 0) {
|
|
944
|
-
modelWriteOff = config.eventBus.on("ui:model", (event) => {
|
|
945
|
-
if (event.type !== "ui:model" || instance.status === "suspended") return;
|
|
946
|
-
if (event.origin !== void 0 && event.origin !== instance.id) return;
|
|
947
|
-
if (event.ref === void 0) return;
|
|
948
|
-
const path = modelListeners.get(event.ref);
|
|
949
|
-
if (path === void 0) return;
|
|
950
|
-
dataStore.update(
|
|
951
|
-
(curr) => applyMutations(curr, [{ set: path, value: event.payload }], { initial: initialSnapshot, strict })
|
|
952
|
-
);
|
|
953
|
-
});
|
|
954
|
-
}
|
|
955
|
-
if (triggerHandle !== void 0) return;
|
|
956
|
-
const triggers = definition.triggers;
|
|
957
|
-
if (triggers === void 0 || triggers.length === 0) return;
|
|
958
|
-
triggerHandle = attachTriggers(triggers, config.eventBus, config.messageBus, buildContext, instance.id);
|
|
959
|
-
};
|
|
960
|
-
const detach = () => {
|
|
961
|
-
if (modelWriteOff !== void 0) {
|
|
962
|
-
modelWriteOff();
|
|
963
|
-
modelWriteOff = void 0;
|
|
964
|
-
}
|
|
965
|
-
if (triggerHandle === void 0) return;
|
|
966
|
-
triggerHandle.detach();
|
|
967
|
-
triggerHandle = void 0;
|
|
968
|
-
};
|
|
969
|
-
const getData = () => dataStore.get();
|
|
970
|
-
const updateData = (updates) => {
|
|
971
|
-
dataStore.update((curr) => ({ ...curr, ...updates }));
|
|
972
|
-
};
|
|
973
|
-
const setData = (next) => {
|
|
974
|
-
dataStore.update(() => next);
|
|
975
|
-
};
|
|
976
|
-
const applyMutationList = (mutations) => {
|
|
977
|
-
if (mutations.length === 0) return;
|
|
978
|
-
dataStore.update(
|
|
979
|
-
(curr) => applyMutations(curr, mutations, { initial: initialSnapshot, strict })
|
|
980
|
-
);
|
|
981
|
-
};
|
|
982
|
-
const StepArraySchema = z.array(StepSchema);
|
|
983
|
-
const runSteps = async (steps) => {
|
|
984
|
-
const parsed = StepArraySchema.safeParse(steps);
|
|
985
|
-
if (!parsed.success) {
|
|
986
|
-
const error = new DefinitionValidationError(
|
|
987
|
-
"Invalid steps passed to runtime.executeSteps",
|
|
988
|
-
{ failures: [{ id: definition.id, issues: parsed.error.issues }] }
|
|
989
|
-
);
|
|
990
|
-
if (strict) throw error;
|
|
991
|
-
onError(error);
|
|
992
|
-
return;
|
|
993
|
-
}
|
|
994
|
-
await executeSteps(parsed.data, buildContext());
|
|
995
|
-
};
|
|
996
|
-
const mount = async (input) => {
|
|
997
|
-
if (input !== void 0) {
|
|
998
|
-
const next = buildInitialData(definition, input);
|
|
999
|
-
dataStore.update(() => next);
|
|
1000
|
-
}
|
|
1001
|
-
attach();
|
|
1002
|
-
const parent = ambientCause();
|
|
1003
|
-
const cause = nextCause(parent);
|
|
1004
|
-
if (isRunaway(cause)) {
|
|
1005
|
-
onError(new NovaError(ErrorCodes.runaway, runawayMessage(cause, `Mounting "${definition.id}"`), { depth: cause.depth, hops: cause.root.hops }));
|
|
1006
|
-
} else {
|
|
1007
|
-
await runLifecycleHook("mount", definition, () => buildContext(abortController.signal, cause));
|
|
1008
|
-
}
|
|
1009
|
-
setStatus("active");
|
|
1010
|
-
};
|
|
1011
|
-
const unmount = async () => {
|
|
1012
|
-
abortController.abort();
|
|
1013
|
-
stopFollowing();
|
|
1014
|
-
detach();
|
|
1015
|
-
teardownModelListeners();
|
|
1016
|
-
const unmountController = new AbortController();
|
|
1017
|
-
await runLifecycleHook(
|
|
1018
|
-
"unmount",
|
|
1019
|
-
definition,
|
|
1020
|
-
() => buildContext(unmountController.signal)
|
|
1021
|
-
);
|
|
1022
|
-
setStatus("unmounted");
|
|
1023
|
-
};
|
|
1024
|
-
const suspend = async () => {
|
|
1025
|
-
await runLifecycleHook("suspend", definition, buildContext);
|
|
1026
|
-
setStatus("suspended");
|
|
1027
|
-
};
|
|
1028
|
-
const resume = async () => {
|
|
1029
|
-
setStatus("active");
|
|
1030
|
-
await runLifecycleHook("mount", definition, buildContext);
|
|
1031
|
-
await runLifecycleHook("resume", definition, buildContext);
|
|
1032
|
-
};
|
|
1033
|
-
const reconcileModelBindings = (nodes) => {
|
|
1034
|
-
modelListeners.clear();
|
|
1035
|
-
for (const b of collectModelBindings(nodes)) modelListeners.set(b.ref, b.path);
|
|
1036
|
-
};
|
|
1037
|
-
const teardownModelListeners = () => {
|
|
1038
|
-
modelListeners.clear();
|
|
1039
|
-
};
|
|
1040
|
-
const render = () => {
|
|
1041
|
-
const language = config.i18n?.();
|
|
1042
|
-
const out = renderRuntime(definition, dataStore, {
|
|
1043
|
-
store: config.layoutStore,
|
|
1044
|
-
registry: config.registry,
|
|
1045
|
-
strict,
|
|
1046
|
-
onError,
|
|
1047
|
-
...language?.phrases === void 0 ? {} : { phrases: language.phrases },
|
|
1048
|
-
...language?.phraseKeys === void 0 ? {} : { phraseKeys: language.phraseKeys },
|
|
1049
|
-
...language?.onPhraseMiss === void 0 ? {} : { onPhraseMiss: language.onPhraseMiss }
|
|
1050
|
-
});
|
|
1051
|
-
reconcileModelBindings(out);
|
|
1052
|
-
return out;
|
|
1053
|
-
};
|
|
1054
|
-
const onDataChange = (handler) => dataStore.subscribe(handler);
|
|
1055
|
-
const onStatusChange = (handler) => {
|
|
1056
|
-
statusSubscribers.push(handler);
|
|
1057
|
-
return () => {
|
|
1058
|
-
const idx = statusSubscribers.indexOf(handler);
|
|
1059
|
-
if (idx >= 0) statusSubscribers.splice(idx, 1);
|
|
1060
|
-
};
|
|
1061
|
-
};
|
|
1062
|
-
const dispose = () => {
|
|
1063
|
-
stopFollowing();
|
|
1064
|
-
detach();
|
|
1065
|
-
teardownModelListeners();
|
|
1066
|
-
statusSubscribers.length = 0;
|
|
1067
|
-
};
|
|
1068
|
-
return {
|
|
1069
|
-
get instance() {
|
|
1070
|
-
return instance;
|
|
1071
|
-
},
|
|
1072
|
-
get definition() {
|
|
1073
|
-
return definition;
|
|
1074
|
-
},
|
|
1075
|
-
get dataStore() {
|
|
1076
|
-
return dataStore;
|
|
1077
|
-
},
|
|
1078
|
-
getData,
|
|
1079
|
-
setData,
|
|
1080
|
-
updateData,
|
|
1081
|
-
applyMutations: applyMutationList,
|
|
1082
|
-
executeSteps: runSteps,
|
|
1083
|
-
mount,
|
|
1084
|
-
unmount,
|
|
1085
|
-
suspend,
|
|
1086
|
-
resume,
|
|
1087
|
-
render,
|
|
1088
|
-
onDataChange,
|
|
1089
|
-
onStatusChange,
|
|
1090
|
-
dispose
|
|
1091
|
-
};
|
|
1092
|
-
};
|
|
1093
|
-
var validateActions = (actions) => {
|
|
1094
|
-
const failures = [];
|
|
1095
|
-
for (const [actionId, def] of Object.entries(actions)) {
|
|
1096
|
-
if (exceedsDepth(def)) {
|
|
1097
|
-
failures.push({ id: actionId, issues: [{ code: "custom", path: [], message: depthRefusal(), input: void 0 }] });
|
|
1098
|
-
continue;
|
|
1099
|
-
}
|
|
1100
|
-
const result = ActionDefinitionSchema.safeParse(def);
|
|
1101
|
-
if (!result.success) failures.push({ id: actionId, issues: result.error.issues });
|
|
1102
|
-
}
|
|
1103
|
-
if (failures.length > 0) {
|
|
1104
|
-
throw new DefinitionValidationError(
|
|
1105
|
-
`${failures.length} action definition(s) failed validation`,
|
|
1106
|
-
{ failures }
|
|
1107
|
-
);
|
|
1108
|
-
}
|
|
1109
|
-
};
|
|
1110
|
-
var validateFragments = (fragments) => {
|
|
1111
|
-
const failures = [];
|
|
1112
|
-
for (const [fragmentId, frag] of Object.entries(fragments)) {
|
|
1113
|
-
if (exceedsDepth(frag)) {
|
|
1114
|
-
failures.push({ id: fragmentId, issues: [{ code: "custom", path: [], message: depthRefusal(), input: void 0 }] });
|
|
1115
|
-
continue;
|
|
1116
|
-
}
|
|
1117
|
-
const result = ActionFragmentSchema.safeParse(frag);
|
|
1118
|
-
if (!result.success) failures.push({ id: fragmentId, issues: result.error.issues });
|
|
1119
|
-
}
|
|
1120
|
-
if (failures.length > 0) {
|
|
1121
|
-
throw new DefinitionValidationError(
|
|
1122
|
-
`${failures.length} action fragment(s) failed validation`,
|
|
1123
|
-
{ failures }
|
|
1124
|
-
);
|
|
1125
|
-
}
|
|
1126
|
-
};
|
|
1127
|
-
var snapshotCanvas = (canvas) => {
|
|
1128
|
-
const stack = canvas.stack.slice();
|
|
1129
|
-
return {
|
|
1130
|
-
id: canvas.id,
|
|
1131
|
-
stack,
|
|
1132
|
-
active: stack.length === 0 ? void 0 : stack[stack.length - 1]
|
|
1133
|
-
};
|
|
1134
|
-
};
|
|
1135
|
-
var createRuntimeFactory = (deps) => (canvasId, definition, input) => createActionRuntime({
|
|
1136
|
-
definition,
|
|
1137
|
-
canvasId,
|
|
1138
|
-
...input === void 0 ? {} : { input },
|
|
1139
|
-
eventBus: deps.eventBus,
|
|
1140
|
-
messageBus: deps.messageBus,
|
|
1141
|
-
layoutStore: deps.layoutStore,
|
|
1142
|
-
registry: deps.registry,
|
|
1143
|
-
...deps.transform === void 0 ? {} : { transform: deps.transform },
|
|
1144
|
-
...deps.fetch === void 0 ? {} : { fetch: deps.fetch },
|
|
1145
|
-
...deps.functions === void 0 ? {} : { functions: deps.functions },
|
|
1146
|
-
...deps.endpointTimeoutMs === void 0 ? {} : { endpointTimeoutMs: deps.endpointTimeoutMs },
|
|
1147
|
-
onNavigate: (effect) => deps.onNavigate(canvasId, effect),
|
|
1148
|
-
...deps.onEndpoint === void 0 ? {} : { onEndpoint: deps.onEndpoint },
|
|
1149
|
-
strict: deps.strict,
|
|
1150
|
-
...deps.onError === void 0 ? {} : { onError: deps.onError },
|
|
1151
|
-
...deps.i18n === void 0 ? {} : { i18n: deps.i18n },
|
|
1152
|
-
instanceIdFn: deps.instanceIdFn
|
|
1153
|
-
});
|
|
1154
|
-
var shellRegistries = /* @__PURE__ */ new WeakMap();
|
|
1155
|
-
var rememberShellRegistry = (shell, registry) => {
|
|
1156
|
-
shellRegistries.set(shell, registry);
|
|
1157
|
-
};
|
|
1158
|
-
|
|
1159
|
-
// src/shell/canvas.ts
|
|
1160
|
-
var createCanvas = (id) => {
|
|
1161
|
-
const stack = [];
|
|
1162
|
-
const peek = () => {
|
|
1163
|
-
if (stack.length === 0) return void 0;
|
|
1164
|
-
return stack[stack.length - 1];
|
|
1165
|
-
};
|
|
1166
|
-
const pushInstance = (inst) => {
|
|
1167
|
-
stack.push(inst);
|
|
1168
|
-
};
|
|
1169
|
-
const popInstance = () => {
|
|
1170
|
-
return stack.pop();
|
|
1171
|
-
};
|
|
1172
|
-
const replaceTop = (inst) => {
|
|
1173
|
-
const prev = stack.pop();
|
|
1174
|
-
stack.push(inst);
|
|
1175
|
-
return prev;
|
|
1176
|
-
};
|
|
1177
|
-
const clearStack = () => {
|
|
1178
|
-
const removed = stack.slice();
|
|
1179
|
-
stack.length = 0;
|
|
1180
|
-
return removed;
|
|
1181
|
-
};
|
|
1182
|
-
return { id, stack, peek, pushInstance, popInstance, replaceTop, clearStack };
|
|
1183
|
-
};
|
|
1184
|
-
|
|
1185
|
-
// src/shell/default-layouts.ts
|
|
1186
|
-
var DEFAULT_SHELL_LAYOUT = {
|
|
1187
|
-
component: "Stack",
|
|
1188
|
-
props: { direction: "row" },
|
|
1189
|
-
children: [
|
|
1190
|
-
{
|
|
1191
|
-
for: "$.canvases",
|
|
1192
|
-
as: "c",
|
|
1193
|
-
key: "id",
|
|
1194
|
-
do: {
|
|
1195
|
-
component: CANVAS_SLOT_NAME,
|
|
1196
|
-
props: { canvasId: "$.c.id" }
|
|
1197
|
-
}
|
|
1198
|
-
}
|
|
1199
|
-
]
|
|
1200
|
-
};
|
|
1201
|
-
var DEFAULT_ACTION_LAYOUT = {
|
|
1202
|
-
component: ACTION_SLOT_NAME,
|
|
1203
|
-
props: { instanceId: "$.active.id" }
|
|
1204
|
-
};
|
|
1205
|
-
|
|
1206
|
-
// src/shell/flatten-render-tree.ts
|
|
1207
|
-
var asString = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
|
|
1208
|
-
var emptyFragment = () => ({ type: "fragment", children: [] });
|
|
1209
|
-
var flattenRenderTree = (tree, shell) => tree.map((node) => flattenNode(node, shell));
|
|
1210
|
-
var flattenNode = (node, shell) => {
|
|
1211
|
-
if (node.type !== "component") {
|
|
1212
|
-
if (node.type === "fragment") {
|
|
1213
|
-
return { type: "fragment", children: flattenRenderTree(node.children, shell) };
|
|
1214
|
-
}
|
|
1215
|
-
return node;
|
|
1216
|
-
}
|
|
1217
|
-
if (node.name === CANVAS_SLOT_NAME) {
|
|
1218
|
-
const canvasId = asString(node.props["canvasId"]);
|
|
1219
|
-
if (canvasId === void 0) return emptyFragment();
|
|
1220
|
-
return { type: "fragment", children: flattenRenderTree(shell.getCanvasRenderTree(canvasId), shell) };
|
|
1221
|
-
}
|
|
1222
|
-
if (node.name === ACTION_SLOT_NAME) {
|
|
1223
|
-
const instanceId = asString(node.props["instanceId"]);
|
|
1224
|
-
if (instanceId === void 0) return emptyFragment();
|
|
1225
|
-
const runtime = shell.getRuntime(instanceId);
|
|
1226
|
-
if (runtime === void 0) return emptyFragment();
|
|
1227
|
-
return {
|
|
1228
|
-
type: "component",
|
|
1229
|
-
name: ACTION_SLOT_NAME,
|
|
1230
|
-
// identity only — never the definition itself (wire weight)
|
|
1231
|
-
props: { instanceId, canvasId: runtime.instance.canvasId, definitionId: runtime.instance.definitionId },
|
|
1232
|
-
children: runtime.render(),
|
|
1233
|
-
// keyed by instance so a renderer remounts when the instance changes
|
|
1234
|
-
// (no stale DOM state across instance swaps, enter animations fire)
|
|
1235
|
-
key: instanceId
|
|
1236
|
-
};
|
|
1237
|
-
}
|
|
1238
|
-
return { ...node, children: flattenRenderTree(node.children, shell) };
|
|
1239
|
-
};
|
|
1240
|
-
|
|
1241
|
-
// src/shell/lifecycle-ops.ts
|
|
1242
|
-
var createLifecycleOps = (deps) => {
|
|
1243
|
-
const { registry, onLifecycleError, onUnmount } = deps;
|
|
1244
|
-
const unmounted = /* @__PURE__ */ new Set();
|
|
1245
|
-
const unmountInstance = (instanceId) => {
|
|
1246
|
-
if (unmounted.has(instanceId)) return;
|
|
1247
|
-
const runtime = registry.get(instanceId);
|
|
1248
|
-
if (runtime === void 0) return;
|
|
1249
|
-
unmounted.add(instanceId);
|
|
1250
|
-
runtime.unmount().catch(onLifecycleError);
|
|
1251
|
-
runtime.dispose();
|
|
1252
|
-
registry.unregister(instanceId);
|
|
1253
|
-
onUnmount?.(instanceId);
|
|
1254
|
-
unmounted.delete(instanceId);
|
|
1255
|
-
};
|
|
1256
|
-
const suspendTop = (canvas) => {
|
|
1257
|
-
const top = canvas.peek();
|
|
1258
|
-
if (top === void 0) return;
|
|
1259
|
-
if (top.status === "suspended") return;
|
|
1260
|
-
const runtime = registry.get(top.id);
|
|
1261
|
-
if (runtime !== void 0) runtime.suspend().catch(onLifecycleError);
|
|
1262
|
-
};
|
|
1263
|
-
const resumeTop = (canvas) => {
|
|
1264
|
-
const top = canvas.peek();
|
|
1265
|
-
if (top === void 0) return;
|
|
1266
|
-
const runtime = registry.get(top.id);
|
|
1267
|
-
if (runtime !== void 0) runtime.resume().catch(onLifecycleError);
|
|
1268
|
-
};
|
|
1269
|
-
return { unmountInstance, suspendTop, resumeTop };
|
|
1270
|
-
};
|
|
1271
|
-
|
|
1272
|
-
// src/shell/runtime-registry.ts
|
|
1273
|
-
var createRuntimeRegistry = () => {
|
|
1274
|
-
const runtimes = /* @__PURE__ */ new Map();
|
|
1275
|
-
const unsubs = /* @__PURE__ */ new Map();
|
|
1276
|
-
const register = (runtime, onData) => {
|
|
1277
|
-
const id = runtime.instance.id;
|
|
1278
|
-
runtimes.set(id, runtime);
|
|
1279
|
-
unsubs.set(id, runtime.onDataChange(onData));
|
|
1280
|
-
};
|
|
1281
|
-
const unregister = (instanceId) => {
|
|
1282
|
-
const off = unsubs.get(instanceId);
|
|
1283
|
-
if (off !== void 0) off();
|
|
1284
|
-
unsubs.delete(instanceId);
|
|
1285
|
-
runtimes.delete(instanceId);
|
|
1286
|
-
};
|
|
1287
|
-
const get = (instanceId) => runtimes.get(instanceId);
|
|
1288
|
-
const disposeAll = () => {
|
|
1289
|
-
for (const off of unsubs.values()) off();
|
|
1290
|
-
unsubs.clear();
|
|
1291
|
-
runtimes.clear();
|
|
1292
|
-
};
|
|
1293
|
-
return { register, unregister, get, disposeAll };
|
|
1294
|
-
};
|
|
1295
|
-
|
|
1296
|
-
// src/shell/telemetry.ts
|
|
1297
|
-
var safeCall = (fn, arg) => {
|
|
1298
|
-
if (fn === void 0) return;
|
|
1299
|
-
try {
|
|
1300
|
-
fn(arg);
|
|
1301
|
-
} catch {
|
|
1302
|
-
}
|
|
1303
|
-
};
|
|
1304
|
-
var createTelemetry = (config) => {
|
|
1305
|
-
const stateSubscribers = [];
|
|
1306
|
-
const dataSubscribers = [];
|
|
1307
|
-
const endpointSubscribers = [];
|
|
1308
|
-
const fireStateChange = (snapshot) => {
|
|
1309
|
-
safeCall(config?.onStateChange, snapshot);
|
|
1310
|
-
for (const handler of stateSubscribers.slice()) safeCall(handler, snapshot);
|
|
1311
|
-
};
|
|
1312
|
-
const fireDataChange = (change) => {
|
|
1313
|
-
safeCall(config?.onDataChange, change);
|
|
1314
|
-
for (const handler of dataSubscribers.slice()) safeCall(handler, change);
|
|
1315
|
-
};
|
|
1316
|
-
const fireEndpoint = (event) => {
|
|
1317
|
-
safeCall(config?.onEndpoint, event);
|
|
1318
|
-
for (const handler of endpointSubscribers.slice()) safeCall(handler, event);
|
|
1319
|
-
};
|
|
1320
|
-
const onStateChange = (handler) => {
|
|
1321
|
-
stateSubscribers.push(handler);
|
|
1322
|
-
return () => {
|
|
1323
|
-
const idx = stateSubscribers.indexOf(handler);
|
|
1324
|
-
if (idx >= 0) stateSubscribers.splice(idx, 1);
|
|
1325
|
-
};
|
|
1326
|
-
};
|
|
1327
|
-
const onDataChange = (handler) => {
|
|
1328
|
-
dataSubscribers.push(handler);
|
|
1329
|
-
return () => {
|
|
1330
|
-
const idx = dataSubscribers.indexOf(handler);
|
|
1331
|
-
if (idx >= 0) dataSubscribers.splice(idx, 1);
|
|
1332
|
-
};
|
|
1333
|
-
};
|
|
1334
|
-
const onEndpoint = (handler) => {
|
|
1335
|
-
endpointSubscribers.push(handler);
|
|
1336
|
-
return () => {
|
|
1337
|
-
const idx = endpointSubscribers.indexOf(handler);
|
|
1338
|
-
if (idx >= 0) endpointSubscribers.splice(idx, 1);
|
|
1339
|
-
};
|
|
1340
|
-
};
|
|
1341
|
-
const clear = () => {
|
|
1342
|
-
stateSubscribers.length = 0;
|
|
1343
|
-
dataSubscribers.length = 0;
|
|
1344
|
-
endpointSubscribers.length = 0;
|
|
1345
|
-
};
|
|
1346
|
-
return { fireStateChange, fireDataChange, fireEndpoint, onStateChange, onDataChange, onEndpoint, clear };
|
|
1347
|
-
};
|
|
1348
|
-
|
|
1349
|
-
// src/shell/shell.ts
|
|
1350
|
-
var defaultShellIdFactory = createIdFactory("shell");
|
|
1351
|
-
var createShell = (config) => {
|
|
1352
|
-
validateActions(config.actions);
|
|
1353
|
-
const id = (config.shellIdFn ?? defaultShellIdFactory)();
|
|
1354
|
-
const instanceIdFn = config.instanceIdFn ?? createIdFactory("act");
|
|
1355
|
-
const strict = config.strict ?? false;
|
|
1356
|
-
const eventBus = config.eventBus ?? createEventBus();
|
|
1357
|
-
const messageBus = config.messageBus ?? createMessageBus();
|
|
1358
|
-
const registry = createRuntimeRegistry();
|
|
1359
|
-
const telemetry = createTelemetry(config.telemetry);
|
|
1360
|
-
const componentRegistry = config.registry ?? createComponentRegistry();
|
|
1361
|
-
if (config.components !== void 0) componentRegistry.registerAll(config.components);
|
|
1362
|
-
const layoutStore = config.layoutStore ?? createLayoutStore();
|
|
1363
|
-
let pendingStrictError;
|
|
1364
|
-
const toLifecycleError = (err) => {
|
|
1365
|
-
if (err instanceof LifecycleError) return err;
|
|
1366
|
-
const message = err instanceof Error ? err.message : String(err);
|
|
1367
|
-
return new LifecycleError(message, {}, { cause: err });
|
|
1368
|
-
};
|
|
1369
|
-
const handleLifecycleRejection = (err) => {
|
|
1370
|
-
const lifecycleErr = toLifecycleError(err);
|
|
1371
|
-
if (strict && pendingStrictError === void 0) {
|
|
1372
|
-
pendingStrictError = lifecycleErr;
|
|
1373
|
-
}
|
|
1374
|
-
if (config.onError === void 0) return;
|
|
1375
|
-
if (err instanceof NovaError) {
|
|
1376
|
-
config.onError(err);
|
|
1377
|
-
return;
|
|
1378
|
-
}
|
|
1379
|
-
config.onError(lifecycleErr);
|
|
1380
|
-
};
|
|
1381
|
-
const origins = /* @__PURE__ */ new Map();
|
|
1382
|
-
const births = /* @__PURE__ */ new Map();
|
|
1383
|
-
const journal = createJournal(config.historyDepth ?? DEFAULT_HISTORY_DEPTH);
|
|
1384
|
-
const ops = createLifecycleOps({
|
|
1385
|
-
registry,
|
|
1386
|
-
onLifecycleError: handleLifecycleRejection,
|
|
1387
|
-
onUnmount: (instanceId) => {
|
|
1388
|
-
origins.delete(instanceId);
|
|
1389
|
-
births.delete(instanceId);
|
|
1390
|
-
}
|
|
1391
|
-
});
|
|
1392
|
-
const canvases = /* @__PURE__ */ new Map();
|
|
1393
|
-
const actionLayouts = /* @__PURE__ */ new Map();
|
|
1394
|
-
const listCanvases = /* @__PURE__ */ new Set();
|
|
1395
|
-
for (const cfg of config.canvases) {
|
|
1396
|
-
canvases.set(cfg.id, createCanvas(cfg.id));
|
|
1397
|
-
if (cfg.actionLayout !== void 0) actionLayouts.set(cfg.id, cfg.actionLayout);
|
|
1398
|
-
if (cfg.mode === "list") listCanvases.add(cfg.id);
|
|
1399
|
-
}
|
|
1400
|
-
const canvasOrder = config.canvases.map((cfg) => cfg.id);
|
|
1401
|
-
let canvasLayout = config.canvasLayout;
|
|
1402
|
-
const actions = { ...config.actions };
|
|
1403
|
-
let phrases = config.phrases;
|
|
1404
|
-
let bearing = config.phrases !== void 0 || config.phraseKeys !== void 0;
|
|
1405
|
-
const SOURCE = {};
|
|
1406
|
-
const language = () => {
|
|
1407
|
-
if (!bearing) return void 0;
|
|
1408
|
-
return {
|
|
1409
|
-
// An empty book translates nothing and still fills patterns, which is
|
|
1410
|
-
// exactly what the source language needs.
|
|
1411
|
-
phrases: phrases ?? SOURCE,
|
|
1412
|
-
...config.phraseKeys === void 0 ? {} : { phraseKeys: config.phraseKeys },
|
|
1413
|
-
...config.onPhraseMiss === void 0 ? {} : { onPhraseMiss: config.onPhraseMiss }
|
|
1414
|
-
};
|
|
1415
|
-
};
|
|
1416
|
-
const fragments = { ...config.fragments ?? {} };
|
|
1417
|
-
let disposed = false;
|
|
1418
|
-
const guardNotDisposed = () => {
|
|
1419
|
-
if (disposed) throw new ShellDisposedError("Shell disposed");
|
|
1420
|
-
};
|
|
1421
|
-
const guardNoPendingStrictError = () => {
|
|
1422
|
-
if (pendingStrictError === void 0) return;
|
|
1423
|
-
const err = pendingStrictError;
|
|
1424
|
-
pendingStrictError = void 0;
|
|
1425
|
-
throw err;
|
|
1426
|
-
};
|
|
1427
|
-
const guard = () => {
|
|
1428
|
-
guardNotDisposed();
|
|
1429
|
-
guardNoPendingStrictError();
|
|
1430
|
-
};
|
|
1431
|
-
const getCanvas = (canvasId) => {
|
|
1432
|
-
const existing = canvases.get(canvasId);
|
|
1433
|
-
if (existing !== void 0) return existing;
|
|
1434
|
-
const created = createCanvas(canvasId);
|
|
1435
|
-
canvases.set(canvasId, created);
|
|
1436
|
-
return created;
|
|
1437
|
-
};
|
|
1438
|
-
const getDefinition = (actionId) => {
|
|
1439
|
-
const def = actions[actionId];
|
|
1440
|
-
if (def === void 0) throw new UnknownActionError(`Unknown action: ${actionId}`, { actionId });
|
|
1441
|
-
return def;
|
|
1442
|
-
};
|
|
1443
|
-
const registerAction = (definition) => {
|
|
1444
|
-
guard();
|
|
1445
|
-
validateActions({ [definition.id]: definition });
|
|
1446
|
-
actions[definition.id] = definition;
|
|
1447
|
-
};
|
|
1448
|
-
const removeAction = (actionId) => {
|
|
1449
|
-
guard();
|
|
1450
|
-
if (actions[actionId] === void 0) return;
|
|
1451
|
-
delete actions[actionId];
|
|
1452
|
-
journal.forgetAction(actionId);
|
|
1453
|
-
let changed = false;
|
|
1454
|
-
for (const [, canvas] of canvases) {
|
|
1455
|
-
if (!canvas.stack.some((inst) => inst.definitionId === actionId)) continue;
|
|
1456
|
-
const previousTop = canvas.peek();
|
|
1457
|
-
for (const inst of canvas.clearStack()) {
|
|
1458
|
-
if (inst.definitionId === actionId) ops.unmountInstance(inst.id);
|
|
1459
|
-
else canvas.pushInstance(inst);
|
|
1460
|
-
}
|
|
1461
|
-
if (canvas.peek() !== previousTop) ops.resumeTop(canvas);
|
|
1462
|
-
changed = true;
|
|
1463
|
-
}
|
|
1464
|
-
if (changed) fireState();
|
|
1465
|
-
};
|
|
1466
|
-
const getFragment = (fragmentId) => {
|
|
1467
|
-
const frag = fragments[fragmentId];
|
|
1468
|
-
if (frag === void 0) throw new UnknownFragmentError(`Unknown fragment: ${fragmentId}`, { fragmentId });
|
|
1469
|
-
return frag;
|
|
1470
|
-
};
|
|
1471
|
-
const registerFragment = (fragment) => {
|
|
1472
|
-
guard();
|
|
1473
|
-
if (fragment.id === void 0) throw new UnknownFragmentError("Fragment is missing an id", { fragmentId: "" });
|
|
1474
|
-
validateFragments({ [fragment.id]: fragment });
|
|
1475
|
-
fragments[fragment.id] = fragment;
|
|
1476
|
-
};
|
|
1477
|
-
const resolveDefinition = (actionId, fragmentIds) => {
|
|
1478
|
-
const def = getDefinition(actionId);
|
|
1479
|
-
if (fragmentIds === void 0 || fragmentIds.length === 0) return def;
|
|
1480
|
-
return composeAction(def, fragmentIds.map(getFragment));
|
|
1481
|
-
};
|
|
1482
|
-
const announced = /* @__PURE__ */ new Map();
|
|
1483
|
-
let announcing = false;
|
|
1484
|
-
const announceNavigation = () => {
|
|
1485
|
-
if (announcing || disposed) return;
|
|
1486
|
-
announcing = true;
|
|
1487
|
-
queueMicrotask(() => {
|
|
1488
|
-
announcing = false;
|
|
1489
|
-
if (disposed) return;
|
|
1490
|
-
for (const [canvasId, canvas] of canvases) {
|
|
1491
|
-
const active = canvas.peek();
|
|
1492
|
-
if (announced.get(canvasId) === active?.id) continue;
|
|
1493
|
-
announced.set(canvasId, active?.id);
|
|
1494
|
-
const message = active === void 0 ? { canvas: canvasId } : { canvas: canvasId, action: active.definitionId, instance: active.id };
|
|
1495
|
-
messageBus.publish(navigatedChannel(canvasId), message);
|
|
1496
|
-
}
|
|
1497
|
-
});
|
|
1498
|
-
};
|
|
1499
|
-
const fireState = () => {
|
|
1500
|
-
if (disposed) return;
|
|
1501
|
-
const out = {};
|
|
1502
|
-
for (const [cid, c] of canvases) out[cid] = snapshotCanvas(c);
|
|
1503
|
-
const snapshot = { canvases: out };
|
|
1504
|
-
telemetry.fireStateChange(snapshot);
|
|
1505
|
-
announceNavigation();
|
|
1506
|
-
};
|
|
1507
|
-
const positionOf = (canvasId) => {
|
|
1508
|
-
const canvas = canvases.get(canvasId);
|
|
1509
|
-
if (canvas === void 0) return [];
|
|
1510
|
-
return canvas.stack.map((inst) => {
|
|
1511
|
-
const birth = births.get(inst.id);
|
|
1512
|
-
return {
|
|
1513
|
-
instance: inst.id,
|
|
1514
|
-
action: birth?.action ?? inst.definitionId,
|
|
1515
|
-
...birth?.input === void 0 ? {} : { input: birth.input },
|
|
1516
|
-
...birth?.with === void 0 ? {} : { with: birth.with }
|
|
1517
|
-
};
|
|
1518
|
-
});
|
|
1519
|
-
};
|
|
1520
|
-
const record = (canvasId) => journal.record(canvasId, positionOf(canvasId));
|
|
1521
|
-
const navigationHandler = createNavigationHandler({
|
|
1522
|
-
push: (cid, aid, input, frags) => push(cid, aid, input, frags),
|
|
1523
|
-
pop: (cid) => pop(cid),
|
|
1524
|
-
replace: (cid, aid, input, frags) => replace(cid, aid, input, frags),
|
|
1525
|
-
clear: (cid) => clear(cid),
|
|
1526
|
-
// ONE position, then both halves — see ShellNavOps.resetTo. The record is
|
|
1527
|
-
// taken outside the mute so the deck being thrown away is what back returns
|
|
1528
|
-
// to; the calls inside it record nothing of their own.
|
|
1529
|
-
resetTo: (cid, aid, input, frags) => {
|
|
1530
|
-
record(cid);
|
|
1531
|
-
journal.mute(() => {
|
|
1532
|
-
clear(cid);
|
|
1533
|
-
push(cid, aid, input, frags);
|
|
1534
|
-
});
|
|
1535
|
-
},
|
|
1536
|
-
popTo: (cid, iid) => popTo(cid, iid),
|
|
1537
|
-
removeInstance: (cid, iid) => removeInstance(cid, iid),
|
|
1538
|
-
// ONE movement, like resetTo: the position before it is what back returns
|
|
1539
|
-
// to — recorded only when something actually moved, so a reconcile that
|
|
1540
|
-
// found the canvas already right leaves no empty step in history. Rows
|
|
1541
|
-
// naming an action this shell does not have are skipped: ungranted is
|
|
1542
|
-
// absent, as an ungranted `initial` candidate is.
|
|
1543
|
-
reconcile: (cid, desired, options) => {
|
|
1544
|
-
const before = positionOf(cid);
|
|
1545
|
-
const known = desired.filter((entry) => actions[entry.actionId] !== void 0).map((entry) => options.with === void 0 ? entry : { ...entry, with: options.with });
|
|
1546
|
-
const result = journal.mute(
|
|
1547
|
-
() => reconcileCanvas(shell, cid, known, {
|
|
1548
|
-
origin: options.origin,
|
|
1549
|
-
...options.own === void 0 ? {} : { own: options.own },
|
|
1550
|
-
definitionOf: (actionId) => actions[actionId]
|
|
1551
|
-
})
|
|
1552
|
-
);
|
|
1553
|
-
if (result.changed) journal.record(cid, before);
|
|
1554
|
-
}
|
|
1555
|
-
});
|
|
1556
|
-
const buildRuntime = createRuntimeFactory({
|
|
1557
|
-
eventBus,
|
|
1558
|
-
messageBus,
|
|
1559
|
-
layoutStore,
|
|
1560
|
-
registry: componentRegistry,
|
|
1561
|
-
...config.transform === void 0 ? {} : { transform: config.transform },
|
|
1562
|
-
...config.fetch === void 0 ? {} : { fetch: config.fetch },
|
|
1563
|
-
...config.functions === void 0 ? {} : { functions: config.functions },
|
|
1564
|
-
...config.endpointTimeoutMs === void 0 ? {} : { endpointTimeoutMs: config.endpointTimeoutMs },
|
|
1565
|
-
strict,
|
|
1566
|
-
...config.onError === void 0 ? {} : { onError: config.onError },
|
|
1567
|
-
i18n: language,
|
|
1568
|
-
instanceIdFn,
|
|
1569
|
-
onNavigate: (cid, effect) => navigationHandler(cid, effect),
|
|
1570
|
-
// Every endpoint call an action makes flows to telemetry — the shell's one
|
|
1571
|
-
// observability surface (state, data, and now endpoints all land here).
|
|
1572
|
-
onEndpoint: (event) => telemetry.fireEndpoint(event)
|
|
1573
|
-
});
|
|
1574
|
-
const spawn = (canvasId, definition, input) => {
|
|
1575
|
-
const runtime = buildRuntime(canvasId, definition, input);
|
|
1576
|
-
const instId = runtime.instance.id;
|
|
1577
|
-
registry.register(runtime, (data) => {
|
|
1578
|
-
if (disposed) return;
|
|
1579
|
-
telemetry.fireDataChange({ instanceId: instId, canvasId: runtime.instance.canvasId, data });
|
|
1580
|
-
});
|
|
1581
|
-
runtime.mount(input).catch(handleLifecycleRejection);
|
|
1582
|
-
return runtime;
|
|
1583
|
-
};
|
|
1584
|
-
const push = (canvasId, actionId, input, fragmentIds, options) => {
|
|
1585
|
-
guard();
|
|
1586
|
-
if (options?.history !== false) record(canvasId);
|
|
1587
|
-
const canvas = getCanvas(canvasId);
|
|
1588
|
-
const definition = resolveDefinition(actionId, fragmentIds);
|
|
1589
|
-
if (!listCanvases.has(canvasId)) ops.suspendTop(canvas);
|
|
1590
|
-
const runtime = spawn(canvasId, definition, input);
|
|
1591
|
-
canvas.pushInstance(runtime.instance);
|
|
1592
|
-
births.set(runtime.instance.id, {
|
|
1593
|
-
action: actionId,
|
|
1594
|
-
...input === void 0 ? {} : { input },
|
|
1595
|
-
...fragmentIds === void 0 ? {} : { with: fragmentIds }
|
|
1596
|
-
});
|
|
1597
|
-
if (options?.origin !== void 0) origins.set(runtime.instance.id, options.origin);
|
|
1598
|
-
fireState();
|
|
1599
|
-
return runtime.instance.id;
|
|
1600
|
-
};
|
|
1601
|
-
const removeInstance = (canvasId, instanceId) => {
|
|
1602
|
-
if (disposed) return;
|
|
1603
|
-
guardNoPendingStrictError();
|
|
1604
|
-
const canvas = canvases.get(canvasId);
|
|
1605
|
-
if (canvas === void 0) return;
|
|
1606
|
-
if (!canvas.stack.some((i) => i.id === instanceId)) return;
|
|
1607
|
-
const previousTop = canvas.peek();
|
|
1608
|
-
for (const inst of canvas.clearStack()) {
|
|
1609
|
-
if (inst.id === instanceId) ops.unmountInstance(inst.id);
|
|
1610
|
-
else canvas.pushInstance(inst);
|
|
1611
|
-
}
|
|
1612
|
-
journal.consume(canvasId);
|
|
1613
|
-
if (!listCanvases.has(canvasId) && canvas.peek() !== previousTop) ops.resumeTop(canvas);
|
|
1614
|
-
fireState();
|
|
1615
|
-
};
|
|
1616
|
-
const pop = (canvasId) => {
|
|
1617
|
-
if (disposed) return;
|
|
1618
|
-
guardNoPendingStrictError();
|
|
1619
|
-
const canvas = canvases.get(canvasId);
|
|
1620
|
-
if (canvas === void 0) return;
|
|
1621
|
-
const top = canvas.popInstance();
|
|
1622
|
-
if (top === void 0) return;
|
|
1623
|
-
ops.unmountInstance(top.id);
|
|
1624
|
-
journal.consume(canvasId);
|
|
1625
|
-
ops.resumeTop(canvas);
|
|
1626
|
-
fireState();
|
|
1627
|
-
};
|
|
1628
|
-
const popTo = (canvasId, instanceId) => {
|
|
1629
|
-
if (disposed) return;
|
|
1630
|
-
guardNoPendingStrictError();
|
|
1631
|
-
const canvas = canvases.get(canvasId);
|
|
1632
|
-
if (canvas === void 0) return;
|
|
1633
|
-
if (!snapshotCanvas(canvas).stack.some((i) => i.id === instanceId)) return;
|
|
1634
|
-
let changed = false;
|
|
1635
|
-
for (; ; ) {
|
|
1636
|
-
const active = snapshotCanvas(canvas).active;
|
|
1637
|
-
if (active === void 0 || active.id === instanceId) break;
|
|
1638
|
-
const top = canvas.popInstance();
|
|
1639
|
-
if (top === void 0) break;
|
|
1640
|
-
ops.unmountInstance(top.id);
|
|
1641
|
-
changed = true;
|
|
1642
|
-
}
|
|
1643
|
-
if (changed) {
|
|
1644
|
-
journal.consume(canvasId);
|
|
1645
|
-
ops.resumeTop(canvas);
|
|
1646
|
-
fireState();
|
|
1647
|
-
}
|
|
1648
|
-
};
|
|
1649
|
-
const replace = (canvasId, actionId, input, fragmentIds) => {
|
|
1650
|
-
guard();
|
|
1651
|
-
record(canvasId);
|
|
1652
|
-
const canvas = getCanvas(canvasId);
|
|
1653
|
-
const definition = resolveDefinition(actionId, fragmentIds);
|
|
1654
|
-
const old = canvas.popInstance();
|
|
1655
|
-
if (old !== void 0) ops.unmountInstance(old.id);
|
|
1656
|
-
const runtime = spawn(canvasId, definition, input);
|
|
1657
|
-
canvas.pushInstance(runtime.instance);
|
|
1658
|
-
births.set(runtime.instance.id, {
|
|
1659
|
-
action: actionId,
|
|
1660
|
-
...input === void 0 ? {} : { input },
|
|
1661
|
-
...fragmentIds === void 0 ? {} : { with: fragmentIds }
|
|
1662
|
-
});
|
|
1663
|
-
fireState();
|
|
1664
|
-
return runtime.instance.id;
|
|
1665
|
-
};
|
|
1666
|
-
const clear = (canvasId) => {
|
|
1667
|
-
if (disposed) return;
|
|
1668
|
-
guardNoPendingStrictError();
|
|
1669
|
-
const canvas = canvases.get(canvasId);
|
|
1670
|
-
if (canvas === void 0) return;
|
|
1671
|
-
if (canvas.stack.length > 0) record(canvasId);
|
|
1672
|
-
for (const inst of canvas.clearStack()) ops.unmountInstance(inst.id);
|
|
1673
|
-
fireState();
|
|
1674
|
-
};
|
|
1675
|
-
const restore = (entry) => {
|
|
1676
|
-
const canvas = canvases.get(entry.canvas);
|
|
1677
|
-
if (canvas === void 0) return false;
|
|
1678
|
-
let common = 0;
|
|
1679
|
-
while (common < canvas.stack.length && common < entry.stack.length && canvas.stack[common]?.id === entry.stack[common]?.instance) {
|
|
1680
|
-
common += 1;
|
|
1681
|
-
}
|
|
1682
|
-
if (common === canvas.stack.length && common === entry.stack.length) return false;
|
|
1683
|
-
for (let i = common; i < entry.stack.length; i += 1) {
|
|
1684
|
-
const frame = entry.stack[i];
|
|
1685
|
-
if (frame !== void 0 && actions[frame.action] === void 0) return false;
|
|
1686
|
-
}
|
|
1687
|
-
journal.mute(() => {
|
|
1688
|
-
const standing = canvas.clearStack();
|
|
1689
|
-
for (let i = 0; i < standing.length; i += 1) {
|
|
1690
|
-
const inst = standing[i];
|
|
1691
|
-
if (inst === void 0) continue;
|
|
1692
|
-
if (i < common) canvas.pushInstance(inst);
|
|
1693
|
-
else ops.unmountInstance(inst.id);
|
|
1694
|
-
}
|
|
1695
|
-
if (common === entry.stack.length) {
|
|
1696
|
-
if (!listCanvases.has(entry.canvas)) ops.resumeTop(canvas);
|
|
1697
|
-
return;
|
|
1698
|
-
}
|
|
1699
|
-
for (let i = common; i < entry.stack.length; i += 1) {
|
|
1700
|
-
const frame = entry.stack[i];
|
|
1701
|
-
if (frame === void 0) continue;
|
|
1702
|
-
push(entry.canvas, frame.action, frame.input, frame.with);
|
|
1703
|
-
}
|
|
1704
|
-
});
|
|
1705
|
-
fireState();
|
|
1706
|
-
return true;
|
|
1707
|
-
};
|
|
1708
|
-
const back = () => {
|
|
1709
|
-
if (disposed) return false;
|
|
1710
|
-
guardNoPendingStrictError();
|
|
1711
|
-
for (; ; ) {
|
|
1712
|
-
const entry = journal.take();
|
|
1713
|
-
if (entry === void 0) return false;
|
|
1714
|
-
if (restore(entry)) return true;
|
|
1715
|
-
}
|
|
1716
|
-
};
|
|
1717
|
-
const seedCanvas = (cfg) => {
|
|
1718
|
-
if (cfg.initial === void 0) return;
|
|
1719
|
-
const seeds = Array.isArray(cfg.initial) ? cfg.initial : [cfg.initial];
|
|
1720
|
-
journal.mute(() => {
|
|
1721
|
-
for (const seed of seeds) {
|
|
1722
|
-
if (typeof seed === "string") push(cfg.id, seed);
|
|
1723
|
-
else push(cfg.id, seed.action, seed.input, seed.with);
|
|
1724
|
-
}
|
|
1725
|
-
});
|
|
1726
|
-
};
|
|
1727
|
-
const addCanvas = (cfg) => {
|
|
1728
|
-
guard();
|
|
1729
|
-
if (canvases.has(cfg.id)) return;
|
|
1730
|
-
canvases.set(cfg.id, createCanvas(cfg.id));
|
|
1731
|
-
if (cfg.actionLayout !== void 0) actionLayouts.set(cfg.id, cfg.actionLayout);
|
|
1732
|
-
canvasOrder.push(cfg.id);
|
|
1733
|
-
seedCanvas(cfg);
|
|
1734
|
-
fireState();
|
|
1735
|
-
};
|
|
1736
|
-
const removeCanvas = (canvasId) => {
|
|
1737
|
-
if (disposed) return;
|
|
1738
|
-
guardNoPendingStrictError();
|
|
1739
|
-
const canvas = canvases.get(canvasId);
|
|
1740
|
-
if (canvas === void 0) return;
|
|
1741
|
-
for (const inst of canvas.clearStack()) ops.unmountInstance(inst.id);
|
|
1742
|
-
canvases.delete(canvasId);
|
|
1743
|
-
journal.forgetCanvas(canvasId);
|
|
1744
|
-
announced.delete(canvasId);
|
|
1745
|
-
actionLayouts.delete(canvasId);
|
|
1746
|
-
const index = canvasOrder.indexOf(canvasId);
|
|
1747
|
-
if (index >= 0) canvasOrder.splice(index, 1);
|
|
1748
|
-
fireState();
|
|
1749
|
-
};
|
|
1750
|
-
const setCanvasLayout = (layout) => {
|
|
1751
|
-
guard();
|
|
1752
|
-
canvasLayout = layout;
|
|
1753
|
-
fireState();
|
|
1754
|
-
};
|
|
1755
|
-
const setLayout = (refId, layout) => {
|
|
1756
|
-
guard();
|
|
1757
|
-
layoutStore.set(refId, layout);
|
|
1758
|
-
fireState();
|
|
1759
|
-
};
|
|
1760
|
-
const setPhrases = (next) => {
|
|
1761
|
-
guard();
|
|
1762
|
-
phrases = next;
|
|
1763
|
-
if (next !== void 0) bearing = true;
|
|
1764
|
-
fireState();
|
|
1765
|
-
};
|
|
1766
|
-
const getPhrases = () => phrases;
|
|
1767
|
-
const getCanvasState = (canvasId) => {
|
|
1768
|
-
guardNoPendingStrictError();
|
|
1769
|
-
const canvas = canvases.get(canvasId);
|
|
1770
|
-
if (canvas === void 0) return { id: canvasId, stack: [], active: void 0 };
|
|
1771
|
-
return snapshotCanvas(canvas);
|
|
1772
|
-
};
|
|
1773
|
-
const dispose = () => {
|
|
1774
|
-
if (disposed) return;
|
|
1775
|
-
disposed = true;
|
|
1776
|
-
for (const [, canvas] of canvases) {
|
|
1777
|
-
for (const inst of canvas.clearStack()) ops.unmountInstance(inst.id);
|
|
1778
|
-
}
|
|
1779
|
-
registry.disposeAll();
|
|
1780
|
-
canvases.clear();
|
|
1781
|
-
telemetry.clear();
|
|
1782
|
-
};
|
|
1783
|
-
const getRuntime = (iid) => registry.get(iid);
|
|
1784
|
-
const onStateChange = (h) => telemetry.onStateChange(h);
|
|
1785
|
-
const onDataChange = (h) => telemetry.onDataChange(h);
|
|
1786
|
-
const onEndpoint = (h) => telemetry.onEndpoint(h);
|
|
1787
|
-
const sameCanvasState = (a, b) => {
|
|
1788
|
-
if (a.stack.length !== b.stack.length) return false;
|
|
1789
|
-
if (a.active?.id !== b.active?.id) return false;
|
|
1790
|
-
for (let i = 0; i < a.stack.length; i += 1) {
|
|
1791
|
-
const aItem = a.stack[i];
|
|
1792
|
-
const bItem = b.stack[i];
|
|
1793
|
-
if (aItem === void 0 || bItem === void 0) return false;
|
|
1794
|
-
if (aItem.id !== bItem.id || aItem.status !== bItem.status) return false;
|
|
1795
|
-
}
|
|
1796
|
-
return true;
|
|
1797
|
-
};
|
|
1798
|
-
const onCanvasChange = (canvasId, handler) => {
|
|
1799
|
-
let prev = getCanvasState(canvasId);
|
|
1800
|
-
return telemetry.onStateChange(() => {
|
|
1801
|
-
const next = getCanvasState(canvasId);
|
|
1802
|
-
if (sameCanvasState(prev, next)) return;
|
|
1803
|
-
prev = next;
|
|
1804
|
-
handler(next);
|
|
1805
|
-
});
|
|
1806
|
-
};
|
|
1807
|
-
const getState = () => {
|
|
1808
|
-
const out = {};
|
|
1809
|
-
for (const [cid, c] of canvases) out[cid] = snapshotCanvas(c);
|
|
1810
|
-
return { canvases: out };
|
|
1811
|
-
};
|
|
1812
|
-
const renderLayoutOrRef = (layout, data) => {
|
|
1813
|
-
const resolved = typeof layout === "string" ? layoutStore.get(layout) : layout;
|
|
1814
|
-
if (resolved === void 0) return [];
|
|
1815
|
-
const current = language();
|
|
1816
|
-
return renderLayoutFromStore(
|
|
1817
|
-
resolved,
|
|
1818
|
-
{ get: () => data },
|
|
1819
|
-
{
|
|
1820
|
-
store: layoutStore,
|
|
1821
|
-
registry: componentRegistry,
|
|
1822
|
-
strict,
|
|
1823
|
-
...config.onError === void 0 ? {} : { onError: config.onError },
|
|
1824
|
-
...current?.phrases === void 0 ? {} : { phrases: current.phrases },
|
|
1825
|
-
...current?.phraseKeys === void 0 ? {} : { phraseKeys: current.phraseKeys },
|
|
1826
|
-
...current?.onPhraseMiss === void 0 ? {} : { onPhraseMiss: current.onPhraseMiss }
|
|
1827
|
-
}
|
|
1828
|
-
);
|
|
1829
|
-
};
|
|
1830
|
-
const getShellRenderTree = () => {
|
|
1831
|
-
const canvasList = [];
|
|
1832
|
-
for (const cid of canvasOrder) {
|
|
1833
|
-
const c = canvases.get(cid);
|
|
1834
|
-
canvasList.push(c === void 0 ? { id: cid, stack: [], active: void 0 } : snapshotCanvas(c));
|
|
1835
|
-
}
|
|
1836
|
-
return renderLayoutOrRef(canvasLayout ?? DEFAULT_SHELL_LAYOUT, { canvases: canvasList });
|
|
1837
|
-
};
|
|
1838
|
-
const titleOf = (instance) => {
|
|
1839
|
-
const def = registry.get(instance.id)?.definition ?? actions[instance.definitionId];
|
|
1840
|
-
if (def?.title !== void 0) {
|
|
1841
|
-
const resolved = resolve(def.title, createScopeChain(instance.data));
|
|
1842
|
-
if (resolved !== void 0 && resolved !== null && resolved !== "") return String(resolved);
|
|
1843
|
-
}
|
|
1844
|
-
return def?.name ?? instance.definitionId;
|
|
1845
|
-
};
|
|
1846
|
-
const getCanvasRenderTree = (canvasId) => {
|
|
1847
|
-
const canvas = canvases.get(canvasId);
|
|
1848
|
-
const state = canvas === void 0 ? { stack: []} : snapshotCanvas(canvas);
|
|
1849
|
-
const instances = state.stack.map((i) => ({ ...i, title: titleOf(i) }));
|
|
1850
|
-
const scope = {
|
|
1851
|
-
instances,
|
|
1852
|
-
active: instances.length === 0 ? void 0 : instances[instances.length - 1],
|
|
1853
|
-
count: instances.length
|
|
1854
|
-
};
|
|
1855
|
-
return renderLayoutOrRef(actionLayouts.get(canvasId) ?? DEFAULT_ACTION_LAYOUT, scope);
|
|
1856
|
-
};
|
|
1857
|
-
const dispatch = (event) => {
|
|
1858
|
-
eventBus.emit(event);
|
|
1859
|
-
};
|
|
1860
|
-
const publish = (channel, payload) => {
|
|
1861
|
-
messageBus.publish(channel, payload);
|
|
1862
|
-
};
|
|
1863
|
-
const shell = {
|
|
1864
|
-
id,
|
|
1865
|
-
registry: componentRegistry,
|
|
1866
|
-
layoutStore,
|
|
1867
|
-
push,
|
|
1868
|
-
originOf: (instanceId) => origins.get(instanceId),
|
|
1869
|
-
pop,
|
|
1870
|
-
popTo,
|
|
1871
|
-
removeInstance,
|
|
1872
|
-
replace,
|
|
1873
|
-
clear,
|
|
1874
|
-
back,
|
|
1875
|
-
registerAction,
|
|
1876
|
-
removeAction,
|
|
1877
|
-
registerFragment,
|
|
1878
|
-
addCanvas,
|
|
1879
|
-
removeCanvas,
|
|
1880
|
-
setCanvasLayout,
|
|
1881
|
-
setPhrases,
|
|
1882
|
-
getPhrases,
|
|
1883
|
-
setLayout,
|
|
1884
|
-
getCanvasState,
|
|
1885
|
-
getRuntime,
|
|
1886
|
-
getState,
|
|
1887
|
-
getShellRenderTree,
|
|
1888
|
-
getCanvasRenderTree,
|
|
1889
|
-
flattenRenderTree: (tree) => flattenRenderTree(tree, shell),
|
|
1890
|
-
dispatch,
|
|
1891
|
-
publish,
|
|
1892
|
-
onStateChange,
|
|
1893
|
-
onDataChange,
|
|
1894
|
-
onEndpoint,
|
|
1895
|
-
onCanvasChange,
|
|
1896
|
-
dispose
|
|
1897
|
-
};
|
|
1898
|
-
rememberShellRegistry(shell, registry);
|
|
1899
|
-
for (const cfg of config.canvases) seedCanvas(cfg);
|
|
1900
|
-
return shell;
|
|
1901
|
-
};
|
|
1902
|
-
|
|
1903
|
-
export { ACTION_SLOT_NAME, CANVAS_SLOT_NAME, DEFAULT_HISTORY_DEPTH, MessageEnvelopeSchema, createIdFactory, createShell, navigatedChannel, reconcileCanvas };
|
|
1904
|
-
//# sourceMappingURL=chunk-LA3BSEMX.js.map
|
|
1905
|
-
//# sourceMappingURL=chunk-LA3BSEMX.js.map
|