@amplitude/amp-semantic 0.0.0-stage → 0.2.0-codexsemantic-review-integration.0
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/LICENSE +21 -0
- package/README.md +245 -2
- package/lib/cjs/capture.d.ts +13 -0
- package/lib/cjs/capture.d.ts.map +1 -0
- package/lib/cjs/capture.js +229 -0
- package/lib/cjs/capture.js.map +1 -0
- package/lib/cjs/helpers.d.ts +9 -0
- package/lib/cjs/helpers.d.ts.map +1 -0
- package/lib/cjs/helpers.js +469 -0
- package/lib/cjs/helpers.js.map +1 -0
- package/lib/cjs/identity.d.ts +4 -0
- package/lib/cjs/identity.d.ts.map +1 -0
- package/lib/cjs/identity.js +27 -0
- package/lib/cjs/identity.js.map +1 -0
- package/lib/cjs/index.d.ts +17 -0
- package/lib/cjs/index.d.ts.map +1 -0
- package/lib/cjs/index.js +43 -0
- package/lib/cjs/index.js.map +1 -0
- package/lib/cjs/recorders/analytics.d.ts +7 -0
- package/lib/cjs/recorders/analytics.d.ts.map +1 -0
- package/lib/cjs/recorders/analytics.js +95 -0
- package/lib/cjs/recorders/analytics.js.map +1 -0
- package/lib/cjs/recorders/feedback.d.ts +4 -0
- package/lib/cjs/recorders/feedback.d.ts.map +1 -0
- package/lib/cjs/recorders/feedback.js +611 -0
- package/lib/cjs/recorders/feedback.js.map +1 -0
- package/lib/cjs/recorders/interactions.d.ts +4 -0
- package/lib/cjs/recorders/interactions.d.ts.map +1 -0
- package/lib/cjs/recorders/interactions.js +320 -0
- package/lib/cjs/recorders/interactions.js.map +1 -0
- package/lib/cjs/recorders/keys.d.ts +4 -0
- package/lib/cjs/recorders/keys.d.ts.map +1 -0
- package/lib/cjs/recorders/keys.js +64 -0
- package/lib/cjs/recorders/keys.js.map +1 -0
- package/lib/cjs/recorders/lifecycle.d.ts +4 -0
- package/lib/cjs/recorders/lifecycle.d.ts.map +1 -0
- package/lib/cjs/recorders/lifecycle.js +86 -0
- package/lib/cjs/recorders/lifecycle.js.map +1 -0
- package/lib/cjs/recorders/navigation.d.ts +4 -0
- package/lib/cjs/recorders/navigation.d.ts.map +1 -0
- package/lib/cjs/recorders/navigation.js +18 -0
- package/lib/cjs/recorders/navigation.js.map +1 -0
- package/lib/cjs/recorders/resource-error.d.ts +4 -0
- package/lib/cjs/recorders/resource-error.d.ts.map +1 -0
- package/lib/cjs/recorders/resource-error.js +159 -0
- package/lib/cjs/recorders/resource-error.js.map +1 -0
- package/lib/cjs/types.d.ts +263 -0
- package/lib/cjs/types.d.ts.map +1 -0
- package/lib/cjs/types.js +5 -0
- package/lib/cjs/types.js.map +1 -0
- package/lib/esm/capture.d.ts +13 -0
- package/lib/esm/capture.d.ts.map +1 -0
- package/lib/esm/capture.js +225 -0
- package/lib/esm/capture.js.map +1 -0
- package/lib/esm/helpers.d.ts +9 -0
- package/lib/esm/helpers.d.ts.map +1 -0
- package/lib/esm/helpers.js +461 -0
- package/lib/esm/helpers.js.map +1 -0
- package/lib/esm/identity.d.ts +4 -0
- package/lib/esm/identity.d.ts.map +1 -0
- package/lib/esm/identity.js +23 -0
- package/lib/esm/identity.js.map +1 -0
- package/lib/esm/index.d.ts +17 -0
- package/lib/esm/index.d.ts.map +1 -0
- package/lib/esm/index.js +27 -0
- package/lib/esm/index.js.map +1 -0
- package/lib/esm/recorders/analytics.d.ts +7 -0
- package/lib/esm/recorders/analytics.d.ts.map +1 -0
- package/lib/esm/recorders/analytics.js +92 -0
- package/lib/esm/recorders/analytics.js.map +1 -0
- package/lib/esm/recorders/feedback.d.ts +4 -0
- package/lib/esm/recorders/feedback.d.ts.map +1 -0
- package/lib/esm/recorders/feedback.js +608 -0
- package/lib/esm/recorders/feedback.js.map +1 -0
- package/lib/esm/recorders/interactions.d.ts +4 -0
- package/lib/esm/recorders/interactions.d.ts.map +1 -0
- package/lib/esm/recorders/interactions.js +317 -0
- package/lib/esm/recorders/interactions.js.map +1 -0
- package/lib/esm/recorders/keys.d.ts +4 -0
- package/lib/esm/recorders/keys.d.ts.map +1 -0
- package/lib/esm/recorders/keys.js +61 -0
- package/lib/esm/recorders/keys.js.map +1 -0
- package/lib/esm/recorders/lifecycle.d.ts +4 -0
- package/lib/esm/recorders/lifecycle.d.ts.map +1 -0
- package/lib/esm/recorders/lifecycle.js +83 -0
- package/lib/esm/recorders/lifecycle.js.map +1 -0
- package/lib/esm/recorders/navigation.d.ts +4 -0
- package/lib/esm/recorders/navigation.d.ts.map +1 -0
- package/lib/esm/recorders/navigation.js +15 -0
- package/lib/esm/recorders/navigation.js.map +1 -0
- package/lib/esm/recorders/resource-error.d.ts +4 -0
- package/lib/esm/recorders/resource-error.d.ts.map +1 -0
- package/lib/esm/recorders/resource-error.js +156 -0
- package/lib/esm/recorders/resource-error.js.map +1 -0
- package/lib/esm/types.d.ts +263 -0
- package/lib/esm/types.d.ts.map +1 -0
- package/lib/esm/types.js +2 -0
- package/lib/esm/types.js.map +1 -0
- package/package.json +35 -3
- package/schema.json +1110 -0
|
@@ -0,0 +1,608 @@
|
|
|
1
|
+
import { __generator, __read, __values } from "tslib";
|
|
2
|
+
var LIVE = '[role="alert"],[role="status"],[role="log"],[aria-live="polite"],[aria-live="assertive"]';
|
|
3
|
+
var DIALOG = 'dialog,[role="dialog"],[role="alertdialog"],[aria-modal="true"]';
|
|
4
|
+
var MAX_BATCHES = 128;
|
|
5
|
+
var MAX_PENDING = 256;
|
|
6
|
+
var MAX_VISITS = 1000;
|
|
7
|
+
var FRAME_MS = 4;
|
|
8
|
+
var DELIVERY_MS = 2;
|
|
9
|
+
var MAX_PAYLOADS = 50;
|
|
10
|
+
/** Walk serialized children without building a second tree or a width-sized queue. */
|
|
11
|
+
function nodes(node, baseline) {
|
|
12
|
+
var stack, frame, current, attrs, hidden;
|
|
13
|
+
var _a;
|
|
14
|
+
return __generator(this, function (_b) {
|
|
15
|
+
switch (_b.label) {
|
|
16
|
+
case 0:
|
|
17
|
+
stack = [{ children: [node], index: 0, hidden: false }];
|
|
18
|
+
_b.label = 1;
|
|
19
|
+
case 1:
|
|
20
|
+
if (!stack.length) return [3 /*break*/, 3];
|
|
21
|
+
frame = stack[stack.length - 1];
|
|
22
|
+
if (frame.index === frame.children.length) {
|
|
23
|
+
stack.pop();
|
|
24
|
+
return [3 /*break*/, 1];
|
|
25
|
+
}
|
|
26
|
+
current = frame.children[frame.index++];
|
|
27
|
+
attrs = current.attributes;
|
|
28
|
+
hidden = frame.hidden || (attrs === null || attrs === void 0 ? void 0 : attrs.hidden) !== undefined || (attrs === null || attrs === void 0 ? void 0 : attrs['aria-hidden']) === 'true';
|
|
29
|
+
return [4 /*yield*/, { node: current, baseline: baseline, hidden: hidden }];
|
|
30
|
+
case 2:
|
|
31
|
+
_b.sent();
|
|
32
|
+
if ((_a = current.childNodes) === null || _a === void 0 ? void 0 : _a.length)
|
|
33
|
+
stack.push({ children: current.childNodes, index: 0, hidden: hidden });
|
|
34
|
+
return [3 /*break*/, 1];
|
|
35
|
+
case 3: return [2 /*return*/];
|
|
36
|
+
}
|
|
37
|
+
});
|
|
38
|
+
}
|
|
39
|
+
function changes(change) {
|
|
40
|
+
var _a, _b, text, e_1_1, _loop_1, _c, _d, attr, e_2_1, parents_1, parentChanged, _e, _f, remove, e_3_1, _g, _h, add, e_4_1;
|
|
41
|
+
var e_1, _j, e_2, _k, e_3, _l, e_4, _m;
|
|
42
|
+
return __generator(this, function (_o) {
|
|
43
|
+
switch (_o.label) {
|
|
44
|
+
case 0:
|
|
45
|
+
if (!(change.type === 'snapshot')) return [3 /*break*/, 2];
|
|
46
|
+
return [5 /*yield**/, __values(nodes(change.node, true))];
|
|
47
|
+
case 1:
|
|
48
|
+
_o.sent();
|
|
49
|
+
return [3 /*break*/, 33];
|
|
50
|
+
case 2:
|
|
51
|
+
_o.trys.push([2, 7, 8, 9]);
|
|
52
|
+
_a = __values(change.texts), _b = _a.next();
|
|
53
|
+
_o.label = 3;
|
|
54
|
+
case 3:
|
|
55
|
+
if (!!_b.done) return [3 /*break*/, 6];
|
|
56
|
+
text = _b.value;
|
|
57
|
+
return [4 /*yield*/, { id: text.id, text: true }];
|
|
58
|
+
case 4:
|
|
59
|
+
_o.sent();
|
|
60
|
+
_o.label = 5;
|
|
61
|
+
case 5:
|
|
62
|
+
_b = _a.next();
|
|
63
|
+
return [3 /*break*/, 3];
|
|
64
|
+
case 6: return [3 /*break*/, 9];
|
|
65
|
+
case 7:
|
|
66
|
+
e_1_1 = _o.sent();
|
|
67
|
+
e_1 = { error: e_1_1 };
|
|
68
|
+
return [3 /*break*/, 9];
|
|
69
|
+
case 8:
|
|
70
|
+
try {
|
|
71
|
+
if (_b && !_b.done && (_j = _a.return)) _j.call(_a);
|
|
72
|
+
}
|
|
73
|
+
finally { if (e_1) throw e_1.error; }
|
|
74
|
+
return [7 /*endfinally*/];
|
|
75
|
+
case 9:
|
|
76
|
+
_loop_1 = function (attr) {
|
|
77
|
+
return __generator(this, function (_p) {
|
|
78
|
+
switch (_p.label) {
|
|
79
|
+
case 0: return [4 /*yield*/, {
|
|
80
|
+
id: attr.id,
|
|
81
|
+
dialogs: ['open', 'hidden', 'aria-hidden', 'role', 'aria-modal'].some(function (key) { return key in attr.attributes; }),
|
|
82
|
+
}];
|
|
83
|
+
case 1:
|
|
84
|
+
_p.sent();
|
|
85
|
+
return [2 /*return*/];
|
|
86
|
+
}
|
|
87
|
+
});
|
|
88
|
+
};
|
|
89
|
+
_o.label = 10;
|
|
90
|
+
case 10:
|
|
91
|
+
_o.trys.push([10, 15, 16, 17]);
|
|
92
|
+
_c = __values(change.attributes), _d = _c.next();
|
|
93
|
+
_o.label = 11;
|
|
94
|
+
case 11:
|
|
95
|
+
if (!!_d.done) return [3 /*break*/, 14];
|
|
96
|
+
attr = _d.value;
|
|
97
|
+
return [5 /*yield**/, _loop_1(attr)];
|
|
98
|
+
case 12:
|
|
99
|
+
_o.sent();
|
|
100
|
+
_o.label = 13;
|
|
101
|
+
case 13:
|
|
102
|
+
_d = _c.next();
|
|
103
|
+
return [3 /*break*/, 11];
|
|
104
|
+
case 14: return [3 /*break*/, 17];
|
|
105
|
+
case 15:
|
|
106
|
+
e_2_1 = _o.sent();
|
|
107
|
+
e_2 = { error: e_2_1 };
|
|
108
|
+
return [3 /*break*/, 17];
|
|
109
|
+
case 16:
|
|
110
|
+
try {
|
|
111
|
+
if (_d && !_d.done && (_k = _c.return)) _k.call(_c);
|
|
112
|
+
}
|
|
113
|
+
finally { if (e_2) throw e_2.error; }
|
|
114
|
+
return [7 /*endfinally*/];
|
|
115
|
+
case 17:
|
|
116
|
+
parents_1 = new Set();
|
|
117
|
+
parentChanged = function (id) {
|
|
118
|
+
var text = !parents_1.has(id);
|
|
119
|
+
if (parents_1.size < MAX_VISITS)
|
|
120
|
+
parents_1.add(id);
|
|
121
|
+
return { id: id, text: text };
|
|
122
|
+
};
|
|
123
|
+
_o.label = 18;
|
|
124
|
+
case 18:
|
|
125
|
+
_o.trys.push([18, 23, 24, 25]);
|
|
126
|
+
_e = __values(change.removes), _f = _e.next();
|
|
127
|
+
_o.label = 19;
|
|
128
|
+
case 19:
|
|
129
|
+
if (!!_f.done) return [3 /*break*/, 22];
|
|
130
|
+
remove = _f.value;
|
|
131
|
+
return [4 /*yield*/, parentChanged(remove.parentId)];
|
|
132
|
+
case 20:
|
|
133
|
+
_o.sent();
|
|
134
|
+
_o.label = 21;
|
|
135
|
+
case 21:
|
|
136
|
+
_f = _e.next();
|
|
137
|
+
return [3 /*break*/, 19];
|
|
138
|
+
case 22: return [3 /*break*/, 25];
|
|
139
|
+
case 23:
|
|
140
|
+
e_3_1 = _o.sent();
|
|
141
|
+
e_3 = { error: e_3_1 };
|
|
142
|
+
return [3 /*break*/, 25];
|
|
143
|
+
case 24:
|
|
144
|
+
try {
|
|
145
|
+
if (_f && !_f.done && (_l = _e.return)) _l.call(_e);
|
|
146
|
+
}
|
|
147
|
+
finally { if (e_3) throw e_3.error; }
|
|
148
|
+
return [7 /*endfinally*/];
|
|
149
|
+
case 25:
|
|
150
|
+
_o.trys.push([25, 31, 32, 33]);
|
|
151
|
+
_g = __values(change.adds), _h = _g.next();
|
|
152
|
+
_o.label = 26;
|
|
153
|
+
case 26:
|
|
154
|
+
if (!!_h.done) return [3 /*break*/, 30];
|
|
155
|
+
add = _h.value;
|
|
156
|
+
return [4 /*yield*/, parentChanged(add.parentId)];
|
|
157
|
+
case 27:
|
|
158
|
+
_o.sent();
|
|
159
|
+
return [5 /*yield**/, __values(nodes(add.node, false))];
|
|
160
|
+
case 28:
|
|
161
|
+
_o.sent();
|
|
162
|
+
_o.label = 29;
|
|
163
|
+
case 29:
|
|
164
|
+
_h = _g.next();
|
|
165
|
+
return [3 /*break*/, 26];
|
|
166
|
+
case 30: return [3 /*break*/, 33];
|
|
167
|
+
case 31:
|
|
168
|
+
e_4_1 = _o.sent();
|
|
169
|
+
e_4 = { error: e_4_1 };
|
|
170
|
+
return [3 /*break*/, 33];
|
|
171
|
+
case 32:
|
|
172
|
+
try {
|
|
173
|
+
if (_h && !_h.done && (_m = _g.return)) _m.call(_g);
|
|
174
|
+
}
|
|
175
|
+
finally { if (e_4) throw e_4.error; }
|
|
176
|
+
return [7 /*endfinally*/];
|
|
177
|
+
case 33: return [2 /*return*/];
|
|
178
|
+
}
|
|
179
|
+
});
|
|
180
|
+
}
|
|
181
|
+
/** Enrich accepted replay changes; never observe or rediscover the DOM independently. */
|
|
182
|
+
export var feedbackRecorder = {
|
|
183
|
+
families: ['notice', 'dialog'],
|
|
184
|
+
setup: function (context) {
|
|
185
|
+
var notices = context.hasCapacity('notice');
|
|
186
|
+
var dialogs = context.hasCapacity('dialog');
|
|
187
|
+
var host = context.host, helpers = context.helpers;
|
|
188
|
+
var window = host.window;
|
|
189
|
+
if ((!notices && !dialogs) || !host.getNode)
|
|
190
|
+
return function () { return undefined; };
|
|
191
|
+
var active = true;
|
|
192
|
+
var lastClick = null;
|
|
193
|
+
var frame;
|
|
194
|
+
var fallbackFrame = false;
|
|
195
|
+
// Bound retained elements as well as per-frame work. Overflow is lossy and
|
|
196
|
+
// reported once per queue through the existing host diagnostics channel.
|
|
197
|
+
var generation = 0;
|
|
198
|
+
var batches = [];
|
|
199
|
+
var trackedDialogs = new Set();
|
|
200
|
+
var pendingNotices = new Set();
|
|
201
|
+
var pendingDialogs = new Set();
|
|
202
|
+
var lastNotices = new WeakMap();
|
|
203
|
+
var seenNotices = new WeakMap();
|
|
204
|
+
var noticeTimers = new Map();
|
|
205
|
+
var dialogStates = new WeakMap();
|
|
206
|
+
var openDialogs = new Set();
|
|
207
|
+
var overflows = new Set();
|
|
208
|
+
var checkStructure = false;
|
|
209
|
+
var nextDialog = false;
|
|
210
|
+
var overflow = function (queue) {
|
|
211
|
+
var _a;
|
|
212
|
+
if (overflows.has(queue))
|
|
213
|
+
return;
|
|
214
|
+
overflows.add(queue);
|
|
215
|
+
try {
|
|
216
|
+
(_a = host.onError) === null || _a === void 0 ? void 0 : _a.call(host, new Error("Semantic feedback ".concat(queue, " limit reached; some changes may be omitted.")));
|
|
217
|
+
}
|
|
218
|
+
catch (_b) {
|
|
219
|
+
/* Diagnostics must not affect the page. */
|
|
220
|
+
}
|
|
221
|
+
};
|
|
222
|
+
var enqueueNotice = function (element, discoveredGeneration) {
|
|
223
|
+
var _a;
|
|
224
|
+
if (!notices || !element.isConnected)
|
|
225
|
+
return;
|
|
226
|
+
if (discoveredGeneration !== undefined && ((_a = seenNotices.get(element)) !== null && _a !== void 0 ? _a : -1) >= discoveredGeneration)
|
|
227
|
+
return;
|
|
228
|
+
if (!pendingNotices.has(element) && !noticeTimers.has(element)) {
|
|
229
|
+
if (pendingNotices.size + noticeTimers.size >= MAX_PENDING) {
|
|
230
|
+
overflow('notice queue');
|
|
231
|
+
return;
|
|
232
|
+
}
|
|
233
|
+
pendingNotices.add(element);
|
|
234
|
+
}
|
|
235
|
+
// Direct mutation intake and later subtree discovery can see the same
|
|
236
|
+
// region. Do not emit it twice for the same mutation batch.
|
|
237
|
+
if (discoveredGeneration !== undefined)
|
|
238
|
+
seenNotices.set(element, discoveredGeneration);
|
|
239
|
+
};
|
|
240
|
+
var enqueueDialog = function (element) {
|
|
241
|
+
if (!dialogs || pendingDialogs.has(element))
|
|
242
|
+
return;
|
|
243
|
+
// Every queued dialog belongs to the bounded trackedDialogs registry.
|
|
244
|
+
pendingDialogs.add(element);
|
|
245
|
+
};
|
|
246
|
+
var unsubscribe = context.subscribe(function (event) {
|
|
247
|
+
if (event.name === 'click')
|
|
248
|
+
lastClick = event.timestamp;
|
|
249
|
+
});
|
|
250
|
+
var cause = function () {
|
|
251
|
+
return lastClick !== null && context.now() - lastClick >= 0 && context.now() - lastClick <= 3000 ? lastClick : null;
|
|
252
|
+
};
|
|
253
|
+
var sendNotice = function (element) {
|
|
254
|
+
if (!active || !element.isConnected || helpers.blocked(element))
|
|
255
|
+
return;
|
|
256
|
+
if (!context.canEmit('notice'))
|
|
257
|
+
return;
|
|
258
|
+
var text = helpers.text(element, undefined, 200);
|
|
259
|
+
if (text !== null && !text.trim())
|
|
260
|
+
return;
|
|
261
|
+
var role = element.getAttribute('role');
|
|
262
|
+
var container = helpers.container(element);
|
|
263
|
+
context.emit('notice', {
|
|
264
|
+
id: helpers.id(element),
|
|
265
|
+
role: role === 'alert' || role === 'status' || role === 'log' ? role : 'live',
|
|
266
|
+
text: text,
|
|
267
|
+
visible: helpers.visible(element),
|
|
268
|
+
region: container ? { role: container.role, name: container.name } : null,
|
|
269
|
+
cause_click_ts: cause(),
|
|
270
|
+
});
|
|
271
|
+
lastNotices.set(element, context.now());
|
|
272
|
+
};
|
|
273
|
+
var readDialog = function (element) {
|
|
274
|
+
var previous = dialogStates.get(element);
|
|
275
|
+
var open = element.isConnected &&
|
|
276
|
+
element.matches(DIALOG) &&
|
|
277
|
+
!element.closest('[hidden],[aria-hidden="true"]') &&
|
|
278
|
+
(element.tagName !== 'DIALOG' || element.hasAttribute('open'));
|
|
279
|
+
var modal = element.getAttribute('aria-modal') === 'true';
|
|
280
|
+
try {
|
|
281
|
+
modal = modal || element.matches(':modal');
|
|
282
|
+
}
|
|
283
|
+
catch (_a) {
|
|
284
|
+
/* Older engines do not support :modal. */
|
|
285
|
+
}
|
|
286
|
+
var description = !element.isConnected && previous ? previous.payload : helpers.describe(element);
|
|
287
|
+
return {
|
|
288
|
+
open: open,
|
|
289
|
+
payload: {
|
|
290
|
+
id: description.id,
|
|
291
|
+
role: element.getAttribute('role') === 'alertdialog' ? 'alertdialog' : 'dialog',
|
|
292
|
+
// Detachment loses masking ancestors and labelledby sources. Never replay a cached name
|
|
293
|
+
// under a potentially stricter current policy; retain only the node identity.
|
|
294
|
+
name: element.isConnected ? description.name : null,
|
|
295
|
+
name_source: element.isConnected ? description.name_source : 'masked',
|
|
296
|
+
state: open ? 'open' : 'closed',
|
|
297
|
+
modal: !element.isConnected && previous ? previous.payload.modal : modal,
|
|
298
|
+
visible: open && helpers.visible(element),
|
|
299
|
+
cause_click_ts: cause(),
|
|
300
|
+
},
|
|
301
|
+
};
|
|
302
|
+
};
|
|
303
|
+
var isOpen = function (element) {
|
|
304
|
+
return element.isConnected &&
|
|
305
|
+
element.matches(DIALOG) &&
|
|
306
|
+
!element.closest('[hidden],[aria-hidden="true"]') &&
|
|
307
|
+
(element.tagName !== 'DIALOG' || element.hasAttribute('open'));
|
|
308
|
+
};
|
|
309
|
+
var clearNotices = function () {
|
|
310
|
+
pendingNotices.clear();
|
|
311
|
+
noticeTimers.forEach(function (timer) { return window.clearTimeout(timer); });
|
|
312
|
+
noticeTimers.clear();
|
|
313
|
+
};
|
|
314
|
+
var cancelFrame = function () {
|
|
315
|
+
if (frame === undefined)
|
|
316
|
+
return;
|
|
317
|
+
if (fallbackFrame)
|
|
318
|
+
window.clearTimeout(frame);
|
|
319
|
+
else
|
|
320
|
+
window.cancelAnimationFrame(frame);
|
|
321
|
+
frame = undefined;
|
|
322
|
+
};
|
|
323
|
+
var cleanup = function () {
|
|
324
|
+
active = false;
|
|
325
|
+
unsubscribeDom();
|
|
326
|
+
unsubscribe();
|
|
327
|
+
cancelFrame();
|
|
328
|
+
clearNotices();
|
|
329
|
+
batches.length = 0;
|
|
330
|
+
trackedDialogs.clear();
|
|
331
|
+
pendingDialogs.clear();
|
|
332
|
+
openDialogs.clear();
|
|
333
|
+
};
|
|
334
|
+
var refreshCapacity = function () {
|
|
335
|
+
if (notices && !context.hasCapacity('notice')) {
|
|
336
|
+
notices = false;
|
|
337
|
+
clearNotices();
|
|
338
|
+
}
|
|
339
|
+
if (dialogs && !context.hasCapacity('dialog')) {
|
|
340
|
+
dialogs = false;
|
|
341
|
+
pendingDialogs.clear();
|
|
342
|
+
openDialogs.clear();
|
|
343
|
+
trackedDialogs.clear();
|
|
344
|
+
}
|
|
345
|
+
if (!notices && !dialogs)
|
|
346
|
+
cleanup();
|
|
347
|
+
return active;
|
|
348
|
+
};
|
|
349
|
+
var processNotice = function (element) {
|
|
350
|
+
pendingNotices.delete(element);
|
|
351
|
+
if (!element.isConnected || noticeTimers.has(element))
|
|
352
|
+
return;
|
|
353
|
+
var last = lastNotices.get(element);
|
|
354
|
+
var remaining = last === undefined ? 0 : 500 - (context.now() - last);
|
|
355
|
+
if (remaining <= 0)
|
|
356
|
+
sendNotice(element);
|
|
357
|
+
else {
|
|
358
|
+
// A trailing timer only transfers its slot back to the ready queue.
|
|
359
|
+
// Text/name/layout work always runs inside the shared frame budget.
|
|
360
|
+
noticeTimers.set(element, window.setTimeout(function () {
|
|
361
|
+
noticeTimers.delete(element);
|
|
362
|
+
if (!active || !notices)
|
|
363
|
+
return;
|
|
364
|
+
enqueueNotice(element);
|
|
365
|
+
if (pendingNotices.size)
|
|
366
|
+
schedule();
|
|
367
|
+
}, remaining));
|
|
368
|
+
}
|
|
369
|
+
};
|
|
370
|
+
var processDialog = function (element) {
|
|
371
|
+
pendingDialogs.delete(element);
|
|
372
|
+
if (helpers.blocked(element)) {
|
|
373
|
+
openDialogs.delete(element);
|
|
374
|
+
trackedDialogs.delete(element);
|
|
375
|
+
return;
|
|
376
|
+
}
|
|
377
|
+
var previous = dialogStates.get(element);
|
|
378
|
+
var open = isOpen(element);
|
|
379
|
+
if ((previous === null || previous === void 0 ? void 0 : previous.open) === open || (!previous && !open))
|
|
380
|
+
return;
|
|
381
|
+
var current = readDialog(element);
|
|
382
|
+
dialogStates.set(element, current);
|
|
383
|
+
if (open)
|
|
384
|
+
openDialogs.add(element);
|
|
385
|
+
else
|
|
386
|
+
openDialogs.delete(element);
|
|
387
|
+
context.emit('dialog', current.payload);
|
|
388
|
+
if (!element.isConnected)
|
|
389
|
+
trackedDialogs.delete(element);
|
|
390
|
+
};
|
|
391
|
+
var flush = function () {
|
|
392
|
+
var e_5, _a, e_6, _b, e_7, _c, e_8, _d;
|
|
393
|
+
frame = undefined;
|
|
394
|
+
if (!active || !refreshCapacity())
|
|
395
|
+
return;
|
|
396
|
+
var start = window.performance.now();
|
|
397
|
+
if (checkStructure) {
|
|
398
|
+
checkStructure = false;
|
|
399
|
+
try {
|
|
400
|
+
// This set is bounded. Never traverse a detached subtree for discovery.
|
|
401
|
+
for (var trackedDialogs_1 = __values(trackedDialogs), trackedDialogs_1_1 = trackedDialogs_1.next(); !trackedDialogs_1_1.done; trackedDialogs_1_1 = trackedDialogs_1.next()) {
|
|
402
|
+
var element = trackedDialogs_1_1.value;
|
|
403
|
+
// A move can change a connected dialog's hidden ancestry too.
|
|
404
|
+
enqueueDialog(element);
|
|
405
|
+
}
|
|
406
|
+
}
|
|
407
|
+
catch (e_5_1) { e_5 = { error: e_5_1 }; }
|
|
408
|
+
finally {
|
|
409
|
+
try {
|
|
410
|
+
if (trackedDialogs_1_1 && !trackedDialogs_1_1.done && (_a = trackedDialogs_1.return)) _a.call(trackedDialogs_1);
|
|
411
|
+
}
|
|
412
|
+
finally { if (e_5) throw e_5.error; }
|
|
413
|
+
}
|
|
414
|
+
try {
|
|
415
|
+
for (var pendingNotices_1 = __values(pendingNotices), pendingNotices_1_1 = pendingNotices_1.next(); !pendingNotices_1_1.done; pendingNotices_1_1 = pendingNotices_1.next()) {
|
|
416
|
+
var element = pendingNotices_1_1.value;
|
|
417
|
+
if (!element.isConnected)
|
|
418
|
+
pendingNotices.delete(element);
|
|
419
|
+
}
|
|
420
|
+
}
|
|
421
|
+
catch (e_6_1) { e_6 = { error: e_6_1 }; }
|
|
422
|
+
finally {
|
|
423
|
+
try {
|
|
424
|
+
if (pendingNotices_1_1 && !pendingNotices_1_1.done && (_b = pendingNotices_1.return)) _b.call(pendingNotices_1);
|
|
425
|
+
}
|
|
426
|
+
finally { if (e_6) throw e_6.error; }
|
|
427
|
+
}
|
|
428
|
+
try {
|
|
429
|
+
for (var noticeTimers_1 = __values(noticeTimers), noticeTimers_1_1 = noticeTimers_1.next(); !noticeTimers_1_1.done; noticeTimers_1_1 = noticeTimers_1.next()) {
|
|
430
|
+
var _e = __read(noticeTimers_1_1.value, 2), element = _e[0], timer = _e[1];
|
|
431
|
+
if (!element.isConnected) {
|
|
432
|
+
window.clearTimeout(timer);
|
|
433
|
+
noticeTimers.delete(element);
|
|
434
|
+
}
|
|
435
|
+
}
|
|
436
|
+
}
|
|
437
|
+
catch (e_7_1) { e_7 = { error: e_7_1 }; }
|
|
438
|
+
finally {
|
|
439
|
+
try {
|
|
440
|
+
if (noticeTimers_1_1 && !noticeTimers_1_1.done && (_c = noticeTimers_1.return)) _c.call(noticeTimers_1);
|
|
441
|
+
}
|
|
442
|
+
finally { if (e_7) throw e_7.error; }
|
|
443
|
+
}
|
|
444
|
+
try {
|
|
445
|
+
for (var trackedDialogs_2 = __values(trackedDialogs), trackedDialogs_2_1 = trackedDialogs_2.next(); !trackedDialogs_2_1.done; trackedDialogs_2_1 = trackedDialogs_2.next()) {
|
|
446
|
+
var element = trackedDialogs_2_1.value;
|
|
447
|
+
if (!element.isConnected && !openDialogs.has(element)) {
|
|
448
|
+
trackedDialogs.delete(element);
|
|
449
|
+
pendingDialogs.delete(element);
|
|
450
|
+
}
|
|
451
|
+
}
|
|
452
|
+
}
|
|
453
|
+
catch (e_8_1) { e_8 = { error: e_8_1 }; }
|
|
454
|
+
finally {
|
|
455
|
+
try {
|
|
456
|
+
if (trackedDialogs_2_1 && !trackedDialogs_2_1.done && (_d = trackedDialogs_2.return)) _d.call(trackedDialogs_2);
|
|
457
|
+
}
|
|
458
|
+
finally { if (e_8) throw e_8.error; }
|
|
459
|
+
}
|
|
460
|
+
}
|
|
461
|
+
var processed = 0;
|
|
462
|
+
var deliver = function (deadline) {
|
|
463
|
+
while (active &&
|
|
464
|
+
(pendingNotices.size || pendingDialogs.size) &&
|
|
465
|
+
processed < MAX_PAYLOADS &&
|
|
466
|
+
window.performance.now() < deadline) {
|
|
467
|
+
var useDialog = pendingDialogs.size > 0 && (nextDialog || !pendingNotices.size);
|
|
468
|
+
nextDialog = !useDialog;
|
|
469
|
+
processed++;
|
|
470
|
+
if (useDialog)
|
|
471
|
+
processDialog(pendingDialogs.values().next().value);
|
|
472
|
+
else
|
|
473
|
+
processNotice(pendingNotices.values().next().value);
|
|
474
|
+
refreshCapacity();
|
|
475
|
+
}
|
|
476
|
+
};
|
|
477
|
+
// Ready events have first access to the frame. Alternate families across
|
|
478
|
+
// frames too, so an expensive notice cannot repeatedly starve a dialog.
|
|
479
|
+
deliver(start + DELIVERY_MS);
|
|
480
|
+
var visited = 0;
|
|
481
|
+
while (active && batches.length && visited++ < MAX_VISITS && window.performance.now() - start < FRAME_MS) {
|
|
482
|
+
var batch = batches[0];
|
|
483
|
+
var item = batch.work.next();
|
|
484
|
+
if (item.done)
|
|
485
|
+
batches.shift();
|
|
486
|
+
else
|
|
487
|
+
consume(item.value, batch.generation);
|
|
488
|
+
}
|
|
489
|
+
deliver(start + FRAME_MS);
|
|
490
|
+
if (active && (checkStructure || batches.length || pendingNotices.size || pendingDialogs.size))
|
|
491
|
+
schedule();
|
|
492
|
+
};
|
|
493
|
+
var schedule = function () {
|
|
494
|
+
if (!active || frame !== undefined)
|
|
495
|
+
return;
|
|
496
|
+
fallbackFrame = typeof window.requestAnimationFrame !== 'function';
|
|
497
|
+
frame = fallbackFrame ? window.setTimeout(flush, 16) : window.requestAnimationFrame(flush);
|
|
498
|
+
};
|
|
499
|
+
var track = function (element) {
|
|
500
|
+
if (trackedDialogs.has(element))
|
|
501
|
+
return true;
|
|
502
|
+
if (trackedDialogs.size >= MAX_PENDING) {
|
|
503
|
+
overflow('dialog tracking');
|
|
504
|
+
return false;
|
|
505
|
+
}
|
|
506
|
+
trackedDialogs.add(element);
|
|
507
|
+
return true;
|
|
508
|
+
};
|
|
509
|
+
var consume = function (work, batchGeneration) {
|
|
510
|
+
var e_9, _a;
|
|
511
|
+
var _b;
|
|
512
|
+
if ('node' in work) {
|
|
513
|
+
var node_1 = work.node, baseline = work.baseline, hidden = work.hidden;
|
|
514
|
+
if (node_1.type !== 2)
|
|
515
|
+
return;
|
|
516
|
+
var attrs = (_b = node_1.attributes) !== null && _b !== void 0 ? _b : {};
|
|
517
|
+
var dialog = node_1.tagName === 'dialog' ||
|
|
518
|
+
attrs.role === 'dialog' ||
|
|
519
|
+
attrs.role === 'alertdialog' ||
|
|
520
|
+
attrs['aria-modal'] === 'true';
|
|
521
|
+
var live = ['alert', 'status', 'log'].includes(attrs.role) ||
|
|
522
|
+
['polite', 'assertive'].includes(attrs['aria-live']);
|
|
523
|
+
if (!(dialogs && dialog) && !(notices && live && !baseline))
|
|
524
|
+
return;
|
|
525
|
+
var element_1 = host.getNode(node_1.id);
|
|
526
|
+
if (!element_1 || element_1.nodeType !== 1 || helpers.blocked(element_1))
|
|
527
|
+
return;
|
|
528
|
+
var target = element_1;
|
|
529
|
+
if (dialogs && dialog && track(target)) {
|
|
530
|
+
if (baseline && !dialogStates.has(target)) {
|
|
531
|
+
// Seed from recorded state, not a later live DOM state. Initial snapshots do
|
|
532
|
+
// not announce pre-existing notices or synthesize dialog-open events.
|
|
533
|
+
var open_1 = !hidden && (node_1.tagName !== 'dialog' || attrs.open !== undefined);
|
|
534
|
+
dialogStates.set(target, {
|
|
535
|
+
open: open_1,
|
|
536
|
+
payload: {
|
|
537
|
+
id: node_1.id,
|
|
538
|
+
role: attrs.role === 'alertdialog' ? 'alertdialog' : 'dialog',
|
|
539
|
+
name: null,
|
|
540
|
+
name_source: 'unnamed',
|
|
541
|
+
state: open_1 ? 'open' : 'closed',
|
|
542
|
+
modal: attrs['aria-modal'] === 'true' || attrs.rr_open_mode === 'modal',
|
|
543
|
+
visible: false,
|
|
544
|
+
cause_click_ts: null,
|
|
545
|
+
},
|
|
546
|
+
});
|
|
547
|
+
if (open_1)
|
|
548
|
+
openDialogs.add(target);
|
|
549
|
+
}
|
|
550
|
+
else {
|
|
551
|
+
var previous = dialogStates.get(target);
|
|
552
|
+
if (previous && baseline)
|
|
553
|
+
previous.payload.id = node_1.id;
|
|
554
|
+
enqueueDialog(target);
|
|
555
|
+
}
|
|
556
|
+
}
|
|
557
|
+
if (notices && live && !baseline)
|
|
558
|
+
enqueueNotice(target, batchGeneration);
|
|
559
|
+
return;
|
|
560
|
+
}
|
|
561
|
+
if (!(notices && work.text) && !(dialogs && work.dialogs))
|
|
562
|
+
return;
|
|
563
|
+
var node = host.getNode(work.id);
|
|
564
|
+
var element = (node === null || node === void 0 ? void 0 : node.nodeType) === 1 ? node : node === null || node === void 0 ? void 0 : node.parentElement;
|
|
565
|
+
if (!element || !element.isConnected || helpers.blocked(element))
|
|
566
|
+
return;
|
|
567
|
+
if (notices && work.text) {
|
|
568
|
+
var region = element.closest(LIVE);
|
|
569
|
+
if (region)
|
|
570
|
+
enqueueNotice(region, batchGeneration);
|
|
571
|
+
}
|
|
572
|
+
if (dialogs && work.dialogs) {
|
|
573
|
+
if (element.matches(DIALOG) && track(element))
|
|
574
|
+
enqueueDialog(element);
|
|
575
|
+
try {
|
|
576
|
+
// Ancestor visibility can affect already recorded dialogs. This registry is
|
|
577
|
+
// bounded; no selector query or subtree walk is needed.
|
|
578
|
+
for (var trackedDialogs_3 = __values(trackedDialogs), trackedDialogs_3_1 = trackedDialogs_3.next(); !trackedDialogs_3_1.done; trackedDialogs_3_1 = trackedDialogs_3.next()) {
|
|
579
|
+
var dialog = trackedDialogs_3_1.value;
|
|
580
|
+
if (element.contains(dialog))
|
|
581
|
+
enqueueDialog(dialog);
|
|
582
|
+
}
|
|
583
|
+
}
|
|
584
|
+
catch (e_9_1) { e_9 = { error: e_9_1 }; }
|
|
585
|
+
finally {
|
|
586
|
+
try {
|
|
587
|
+
if (trackedDialogs_3_1 && !trackedDialogs_3_1.done && (_a = trackedDialogs_3.return)) _a.call(trackedDialogs_3);
|
|
588
|
+
}
|
|
589
|
+
finally { if (e_9) throw e_9.error; }
|
|
590
|
+
}
|
|
591
|
+
}
|
|
592
|
+
};
|
|
593
|
+
var unsubscribeDom = context.on('dom', function (change) {
|
|
594
|
+
if (!active || !refreshCapacity())
|
|
595
|
+
return;
|
|
596
|
+
generation++;
|
|
597
|
+
if (change.type === 'snapshot' || change.removes.length)
|
|
598
|
+
checkStructure = true;
|
|
599
|
+
if (batches.length >= MAX_BATCHES)
|
|
600
|
+
overflow('replay batch queue');
|
|
601
|
+
else
|
|
602
|
+
batches.push({ work: changes(change), generation: generation });
|
|
603
|
+
schedule();
|
|
604
|
+
});
|
|
605
|
+
return cleanup;
|
|
606
|
+
},
|
|
607
|
+
};
|
|
608
|
+
//# sourceMappingURL=feedback.js.map
|