@egret/runtime 0.0.0-stage → 7.0.2
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 +201 -0
- package/NOTICE +21 -0
- package/README.md +70 -2
- package/README.zh-CN.md +71 -0
- package/dist/AssetLease.d.ts +23 -0
- package/dist/AssetLease.js +69 -0
- package/dist/AssetManager.d.ts +58 -0
- package/dist/AssetManager.js +451 -0
- package/dist/AssetRef.d.ts +21 -0
- package/dist/AssetRef.js +33 -0
- package/dist/Bitmap.d.ts +40 -0
- package/dist/Bitmap.js +545 -0
- package/dist/ByteReader.d.ts +32 -0
- package/dist/ByteReader.js +178 -0
- package/dist/ByteWriter.d.ts +30 -0
- package/dist/ByteWriter.js +181 -0
- package/dist/CancellationController.d.ts +10 -0
- package/dist/CancellationController.js +66 -0
- package/dist/DisplayObject.d.ts +97 -0
- package/dist/DisplayObject.js +366 -0
- package/dist/DisplayObjectContainer.d.ts +28 -0
- package/dist/DisplayObjectContainer.js +226 -0
- package/dist/EgretError.d.ts +12 -0
- package/dist/EgretError.js +36 -0
- package/dist/Event.d.ts +47 -0
- package/dist/Event.js +84 -0
- package/dist/EventDispatcher.d.ts +24 -0
- package/dist/EventDispatcher.js +178 -0
- package/dist/Graphics.d.ts +117 -0
- package/dist/Graphics.js +548 -0
- package/dist/Mesh2D.d.ts +27 -0
- package/dist/Mesh2D.js +200 -0
- package/dist/NineSliceBitmap.d.ts +24 -0
- package/dist/NineSliceBitmap.js +164 -0
- package/dist/NineSliceGeometry2D.d.ts +19 -0
- package/dist/NineSliceGeometry2D.js +126 -0
- package/dist/Scope.d.ts +19 -0
- package/dist/Scope.js +133 -0
- package/dist/SequencePlayer.d.ts +12 -0
- package/dist/SequencePlayer.js +69 -0
- package/dist/Sprite.d.ts +8 -0
- package/dist/Sprite.js +12 -0
- package/dist/Stage.d.ts +14 -0
- package/dist/Stage.js +31 -0
- package/dist/Texture.d.ts +30 -0
- package/dist/Texture.js +178 -0
- package/dist/assetManagerOwnerState.d.ts +36 -0
- package/dist/assetManagerOwnerState.js +115 -0
- package/dist/assetState.d.ts +45 -0
- package/dist/assetState.js +2 -0
- package/dist/atlasFrameLayout.d.ts +21 -0
- package/dist/atlasFrameLayout.js +48 -0
- package/dist/bitmapDisplayState.d.ts +24 -0
- package/dist/bitmapDisplayState.js +22 -0
- package/dist/coordinateInverse.d.ts +4 -0
- package/dist/coordinateInverse.js +107 -0
- package/dist/diagnostics.d.ts +4 -0
- package/dist/diagnostics.js +13 -0
- package/dist/displayBounds.d.ts +9 -0
- package/dist/displayBounds.js +181 -0
- package/dist/displayCoordinates.d.ts +8 -0
- package/dist/displayCoordinates.js +81 -0
- package/dist/displayHitState.d.ts +18 -0
- package/dist/displayHitState.js +97 -0
- package/dist/displayHitTest.d.ts +8 -0
- package/dist/displayHitTest.js +219 -0
- package/dist/displayInputOperations.d.ts +12 -0
- package/dist/displayInputOperations.js +71 -0
- package/dist/displayTransform.d.ts +5 -0
- package/dist/displayTransform.js +38 -0
- package/dist/displayTreeState.d.ts +90 -0
- package/dist/displayTreeState.js +450 -0
- package/dist/displayVisualState.d.ts +76 -0
- package/dist/displayVisualState.js +141 -0
- package/dist/errorHelp.d.ts +15 -0
- package/dist/errorHelp.js +435 -0
- package/dist/errorHelpZh.d.ts +5 -0
- package/dist/errorHelpZh.js +342 -0
- package/dist/geometry.d.ts +173 -0
- package/dist/geometry.js +311 -0
- package/dist/graphicsFill.d.ts +37 -0
- package/dist/graphicsFill.js +302 -0
- package/dist/graphicsShape.d.ts +170 -0
- package/dist/graphicsShape.js +961 -0
- package/dist/index.d.ts +53 -0
- package/dist/index.js +31 -0
- package/dist/input/PointerRouter.d.ts +4 -0
- package/dist/input/PointerRouter.js +453 -0
- package/dist/input/index.d.ts +3 -0
- package/dist/input/index.js +3 -0
- package/dist/input/types.d.ts +64 -0
- package/dist/input/types.js +3 -0
- package/dist/meshCaptureSnapshot.d.ts +5 -0
- package/dist/meshCaptureSnapshot.js +13 -0
- package/dist/meshDisplayState.d.ts +18 -0
- package/dist/meshDisplayState.js +21 -0
- package/dist/ownership.d.ts +75 -0
- package/dist/ownership.js +157 -0
- package/dist/paragraph/Paragraph.d.ts +13 -0
- package/dist/paragraph/Paragraph.js +193 -0
- package/dist/paragraph/ParagraphCache.d.ts +5 -0
- package/dist/paragraph/ParagraphCache.js +354 -0
- package/dist/paragraph/geometry.d.ts +4 -0
- package/dist/paragraph/geometry.js +180 -0
- package/dist/paragraph/index.d.ts +3 -0
- package/dist/paragraph/index.js +3 -0
- package/dist/paragraph/request.d.ts +6 -0
- package/dist/paragraph/request.js +191 -0
- package/dist/paragraph/types.d.ts +183 -0
- package/dist/paragraph/types.js +2 -0
- package/dist/preparedDisplaySubtree.d.ts +7 -0
- package/dist/preparedDisplaySubtree.js +205 -0
- package/dist/renderEffect.d.ts +57 -0
- package/dist/renderEffect.js +109 -0
- package/dist/sequenceClip.d.ts +48 -0
- package/dist/sequenceClip.js +197 -0
- package/dist/sharedFrameCapture.d.ts +24 -0
- package/dist/sharedFrameCapture.js +1128 -0
- package/dist/spriteSheet.d.ts +34 -0
- package/dist/spriteSheet.js +321 -0
- package/dist/srgbBytes.d.ts +3 -0
- package/dist/srgbBytes.js +64 -0
- package/dist/text/TextField.d.ts +13 -0
- package/dist/text/TextField.js +261 -0
- package/dist/text/TextRasterCache.d.ts +5 -0
- package/dist/text/TextRasterCache.js +1191 -0
- package/dist/text/budget.d.ts +51 -0
- package/dist/text/budget.js +116 -0
- package/dist/text/index.d.ts +4 -0
- package/dist/text/index.js +3 -0
- package/dist/text/plan.d.ts +16 -0
- package/dist/text/plan.js +238 -0
- package/dist/text/request.d.ts +44 -0
- package/dist/text/request.js +303 -0
- package/dist/text/types.d.ts +179 -0
- package/dist/text/types.js +2 -0
- package/dist/textDisplayState.d.ts +21 -0
- package/dist/textDisplayState.js +27 -0
- package/dist/ui/displayCommit.d.ts +43 -0
- package/dist/ui/displayCommit.js +384 -0
- package/dist/ui/editing.d.ts +3 -0
- package/dist/ui/editing.js +3 -0
- package/dist/ui/heightIndex.d.ts +35 -0
- package/dist/ui/heightIndex.js +295 -0
- package/dist/ui/index.d.ts +6 -0
- package/dist/ui/index.js +6 -0
- package/dist/ui/layout.d.ts +9 -0
- package/dist/ui/layout.js +349 -0
- package/dist/ui/managedState.d.ts +12 -0
- package/dist/ui/managedState.js +44 -0
- package/dist/ui/textEditState.d.ts +4 -0
- package/dist/ui/textEditState.js +206 -0
- package/dist/ui/textEditTypes.d.ts +48 -0
- package/dist/ui/textEditTypes.js +2 -0
- package/dist/ui/types.d.ts +99 -0
- package/dist/ui/types.js +2 -0
- package/package.json +44 -4
|
@@ -0,0 +1,1191 @@
|
|
|
1
|
+
import { isImageData2D } from '@egret/contracts';
|
|
2
|
+
import { AssetLease, observeAssetLeaseRetirement, readAssetLeaseValue } from '../AssetLease.js';
|
|
3
|
+
import { createAssetRef, createAssetType } from '../AssetRef.js';
|
|
4
|
+
import { CancellationController } from '../CancellationController.js';
|
|
5
|
+
import { EgretError } from '../EgretError.js';
|
|
6
|
+
import { beginTextCacheCreation, commitTextCacheLifetime, requireAssetManagerOwner } from '../assetManagerOwnerState.js';
|
|
7
|
+
import { commitBinding } from '../ownership.js';
|
|
8
|
+
import { createTexture, isTexture, readTextureSnapshot, Texture } from '../Texture.js';
|
|
9
|
+
import { TextBudget, TEXT_BUDGET_DEFAULTS, TEXT_BUDGET_MINIMA } from './budget.js';
|
|
10
|
+
import { closeTextValueInvocation, createOwnedTextRasterRequest, createTextFieldRequestInput, createTextValueFailure, createTextValueInvocation, matchesTextRasterRequestSummary, snapshotTextRasterRequest, summarizeTextRasterRequest, takeTextValueFailure } from './request.js';
|
|
11
|
+
import { createTextFieldLeaf } from './TextField.js';
|
|
12
|
+
import { closeTextRasterPlanIssuer, createTextRasterPlanIssuer, readIssuedTextRasterPlan, requireIssuedTextRasterPlan } from './plan.js';
|
|
13
|
+
const APPLY = Reflect.apply;
|
|
14
|
+
const FREEZE = Object.freeze;
|
|
15
|
+
const WEAK_GET = WeakMap.prototype.get;
|
|
16
|
+
const WEAK_SET = WeakMap.prototype.set;
|
|
17
|
+
const SAFE_INTEGER = Number.isSafeInteger;
|
|
18
|
+
const REGEXP_EXEC = RegExp.prototype.exec;
|
|
19
|
+
const PROVIDER_IDENTITY = /^[A-Za-z0-9._-]{1,64}$/;
|
|
20
|
+
const LIMIT_KEYS = FREEZE([
|
|
21
|
+
'maxGenerations',
|
|
22
|
+
'maxPendingJobs',
|
|
23
|
+
'maxWaiters',
|
|
24
|
+
'maxCallerLeases',
|
|
25
|
+
'maxResidentEntries',
|
|
26
|
+
'maxMetadataBytes',
|
|
27
|
+
'maxLogicalImageBytes',
|
|
28
|
+
'maxPendingRasterBytes'
|
|
29
|
+
]);
|
|
30
|
+
const ABORT = CancellationController.prototype.abort;
|
|
31
|
+
const RELEASE_LEASE = AssetLease.prototype.release;
|
|
32
|
+
const DISPOSE_TEXTURE = Texture.prototype.dispose;
|
|
33
|
+
const PROFILE = 'canvas-explicit-lines-v1';
|
|
34
|
+
const LIMITS = FREEZE({
|
|
35
|
+
maxSourceCodeUnits: 8192,
|
|
36
|
+
maxLines: 64,
|
|
37
|
+
maxFontFamilyCodeUnits: 256,
|
|
38
|
+
maxLocaleCodeUnits: 64,
|
|
39
|
+
maxProviderIdentityCodeUnits: 64,
|
|
40
|
+
maxSourceEdge: 4096,
|
|
41
|
+
maxSourcePixels: 1048576,
|
|
42
|
+
maxMetricMagnitude: 1048576,
|
|
43
|
+
antialiasGuardPixels: 2
|
|
44
|
+
});
|
|
45
|
+
const states = new WeakMap();
|
|
46
|
+
function stateOf(value) {
|
|
47
|
+
const state = APPLY(WEAK_GET, states, [value]);
|
|
48
|
+
if (state === undefined)
|
|
49
|
+
throw new EgretError('TEXT_CACHE_INVALID');
|
|
50
|
+
return state;
|
|
51
|
+
}
|
|
52
|
+
function assertOpen(state) {
|
|
53
|
+
try {
|
|
54
|
+
state.owner.assertOpen();
|
|
55
|
+
}
|
|
56
|
+
catch (cause) {
|
|
57
|
+
throw new EgretError('TEXT_CACHE_CLOSED', { cause });
|
|
58
|
+
}
|
|
59
|
+
if (state.closed)
|
|
60
|
+
throw new EgretError('TEXT_CACHE_CLOSED');
|
|
61
|
+
}
|
|
62
|
+
function assertMutable(state) {
|
|
63
|
+
assertOpen(state);
|
|
64
|
+
if (state.busy)
|
|
65
|
+
throw new EgretError('TEXT_CACHE_REENTRANT');
|
|
66
|
+
}
|
|
67
|
+
function remove(array, value) {
|
|
68
|
+
const index = array.indexOf(value);
|
|
69
|
+
if (index !== -1)
|
|
70
|
+
array.splice(index, 1);
|
|
71
|
+
}
|
|
72
|
+
function touch(state, generation) {
|
|
73
|
+
remove(state.lru, generation);
|
|
74
|
+
if (generation.current)
|
|
75
|
+
state.lru.push(generation);
|
|
76
|
+
}
|
|
77
|
+
function increment(value) {
|
|
78
|
+
if (!SAFE_INTEGER(value + 1))
|
|
79
|
+
throw new EgretError('TEXT_COUNTER_EXHAUSTED');
|
|
80
|
+
return value + 1;
|
|
81
|
+
}
|
|
82
|
+
function recordCleanup(state, cause, code, managerOwned = false) {
|
|
83
|
+
if (!state.hasCleanupFailure) {
|
|
84
|
+
state.hasCleanupFailure = true;
|
|
85
|
+
state.firstCleanupCause = cause;
|
|
86
|
+
}
|
|
87
|
+
const count = state.budget.snapshot().cleanupFailureCount;
|
|
88
|
+
if (count < Number.MAX_SAFE_INTEGER)
|
|
89
|
+
state.budget.commit({ cleanupFailureCount: 1 });
|
|
90
|
+
if (!managerOwned) {
|
|
91
|
+
state.owner.context.captureCleanup(cause);
|
|
92
|
+
state.owner.context.report({ code, phase: 'assets', severity: 'error', cause });
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
function controller(state) {
|
|
96
|
+
return new CancellationController(diagnostic => {
|
|
97
|
+
if (!state.hasCleanupFailure) {
|
|
98
|
+
state.hasCleanupFailure = true;
|
|
99
|
+
state.firstCleanupCause = diagnostic.cause;
|
|
100
|
+
}
|
|
101
|
+
if (state.budget.snapshot().cleanupFailureCount < Number.MAX_SAFE_INTEGER)
|
|
102
|
+
state.budget.commit({ cleanupFailureCount: 1 });
|
|
103
|
+
state.owner.context.captureCleanup(diagnostic.cause);
|
|
104
|
+
state.owner.context.report(diagnostic);
|
|
105
|
+
});
|
|
106
|
+
}
|
|
107
|
+
function abort(value, reason) {
|
|
108
|
+
APPLY(ABORT, value, [reason]);
|
|
109
|
+
}
|
|
110
|
+
function release(lease) {
|
|
111
|
+
APPLY(RELEASE_LEASE, lease, []);
|
|
112
|
+
}
|
|
113
|
+
function collect(state, generation) {
|
|
114
|
+
if (generation.current ||
|
|
115
|
+
generation.actors !== 0 ||
|
|
116
|
+
generation.callers !== 0 ||
|
|
117
|
+
generation.resident ||
|
|
118
|
+
generation.image !== undefined ||
|
|
119
|
+
generation.reservedBytes !== 0 ||
|
|
120
|
+
generation.scratchBytes !== 0 ||
|
|
121
|
+
generation.quarantined)
|
|
122
|
+
return;
|
|
123
|
+
if (state.generations.delete(generation))
|
|
124
|
+
state.budget.commit({ retiredGenerations: -1, metadataBytes: -generation.metadata });
|
|
125
|
+
}
|
|
126
|
+
function settleIdle(state) {
|
|
127
|
+
if (state.actors !== 0)
|
|
128
|
+
return;
|
|
129
|
+
for (const waiter of state.idle) {
|
|
130
|
+
state.idle.delete(waiter);
|
|
131
|
+
state.budget.commit({ idleWaiters: -1, metadataBytes: -64 });
|
|
132
|
+
if (state.hasCleanupFailure)
|
|
133
|
+
waiter.reject(new EgretError('TEXT_CACHE_CLEANUP_FAILED', { cause: state.firstCleanupCause }));
|
|
134
|
+
else
|
|
135
|
+
waiter.resolve();
|
|
136
|
+
}
|
|
137
|
+
}
|
|
138
|
+
function beginActor(state, generation) {
|
|
139
|
+
state.actors += 1;
|
|
140
|
+
generation.actors += 1;
|
|
141
|
+
}
|
|
142
|
+
function endActor(state, generation) {
|
|
143
|
+
generation.actors -= 1;
|
|
144
|
+
state.actors -= 1;
|
|
145
|
+
if (generation.workSettled && generation.actors === 0 && generation.jobCharged) {
|
|
146
|
+
generation.jobCharged = false;
|
|
147
|
+
state.budget.commit({ pendingJobs: -1 });
|
|
148
|
+
}
|
|
149
|
+
collect(state, generation);
|
|
150
|
+
settleIdle(state);
|
|
151
|
+
}
|
|
152
|
+
/** Retire routing before any manager invalidation, abort, or disposer callback. */
|
|
153
|
+
function retireRoute(state, generation) {
|
|
154
|
+
if (!generation.current)
|
|
155
|
+
return;
|
|
156
|
+
generation.current = false;
|
|
157
|
+
if (generation.slot.current === generation)
|
|
158
|
+
generation.slot.current = undefined;
|
|
159
|
+
remove(state.lru, generation);
|
|
160
|
+
state.budget.commit({ occupiedSlots: -1, currentGenerations: -1, retiredGenerations: 1 });
|
|
161
|
+
}
|
|
162
|
+
function dropResidency(state, generation) {
|
|
163
|
+
// A manager revocation refunds counters before its cache-closing hook. Retire
|
|
164
|
+
// the strong bookkeeping references here even when that observer already ran.
|
|
165
|
+
remove(state.residentLru, generation);
|
|
166
|
+
const lease = generation.residentLease;
|
|
167
|
+
generation.residentLease = undefined;
|
|
168
|
+
if (!generation.resident) {
|
|
169
|
+
collect(state, generation);
|
|
170
|
+
return;
|
|
171
|
+
}
|
|
172
|
+
if (lease === undefined) {
|
|
173
|
+
generation.resident = false;
|
|
174
|
+
state.budget.commit({ residentEntries: -1, metadataBytes: -64 });
|
|
175
|
+
}
|
|
176
|
+
else
|
|
177
|
+
release(lease); // Its counter-only observer commits retirement before disposal.
|
|
178
|
+
collect(state, generation);
|
|
179
|
+
}
|
|
180
|
+
function retire(state, generation, invalidate) {
|
|
181
|
+
retireRoute(state, generation);
|
|
182
|
+
if (invalidate)
|
|
183
|
+
state.owner.invalidate(generation.slot.ref);
|
|
184
|
+
dropResidency(state, generation);
|
|
185
|
+
collect(state, generation);
|
|
186
|
+
}
|
|
187
|
+
function quarantine(state, generation) {
|
|
188
|
+
retireRoute(state, generation);
|
|
189
|
+
if (generation.quarantined)
|
|
190
|
+
return;
|
|
191
|
+
generation.quarantined = true;
|
|
192
|
+
state.budget.commit({
|
|
193
|
+
quarantinedGenerations: 1,
|
|
194
|
+
quarantinedImageBytes: generation.imageBytes + generation.reservedBytes,
|
|
195
|
+
quarantinedRasterBytes: generation.scratchBytes
|
|
196
|
+
});
|
|
197
|
+
}
|
|
198
|
+
function detach(state, waiter) {
|
|
199
|
+
if (waiter.installing || !waiter.listening || waiter.signal === undefined)
|
|
200
|
+
return [];
|
|
201
|
+
waiter.listening = false;
|
|
202
|
+
try {
|
|
203
|
+
APPLY(waiter.signal.remove, waiter.signal.signal, ['abort', waiter.listener]);
|
|
204
|
+
return [];
|
|
205
|
+
}
|
|
206
|
+
catch (cause) {
|
|
207
|
+
recordCleanup(state, cause, 'TEXT_SIGNAL_FAILED');
|
|
208
|
+
return [cause];
|
|
209
|
+
}
|
|
210
|
+
}
|
|
211
|
+
function associate(error, causes) {
|
|
212
|
+
return causes.length === 0
|
|
213
|
+
? error
|
|
214
|
+
: new EgretError(error.code, { cause: error.cause, cleanupErrors: [...error.cleanupErrors, ...causes] });
|
|
215
|
+
}
|
|
216
|
+
function rejectInert(state, waiter) {
|
|
217
|
+
if (waiter.installing || waiter.error === undefined)
|
|
218
|
+
return;
|
|
219
|
+
const error = waiter.error;
|
|
220
|
+
waiter.error = undefined;
|
|
221
|
+
waiter.reject(associate(error, detach(state, waiter)));
|
|
222
|
+
}
|
|
223
|
+
function makeInert(state, waiter, error) {
|
|
224
|
+
if (!waiter.pending)
|
|
225
|
+
return;
|
|
226
|
+
waiter.pending = false;
|
|
227
|
+
waiter.error = error;
|
|
228
|
+
waiter.generation.waiters.delete(waiter);
|
|
229
|
+
state.budget.commit({ pendingWaiters: -1, callerLeaseSlots: -1, metadataBytes: -192 });
|
|
230
|
+
}
|
|
231
|
+
function failWaiter(state, waiter, error) {
|
|
232
|
+
if (!waiter.pending)
|
|
233
|
+
return;
|
|
234
|
+
makeInert(state, waiter, error);
|
|
235
|
+
const generation = waiter.generation;
|
|
236
|
+
if (generation.waiters.size === 0 &&
|
|
237
|
+
(generation.kind === 'loading' ||
|
|
238
|
+
(generation.callers === 0 && !generation.resident && !generation.residencyPending))) {
|
|
239
|
+
retireRoute(state, generation);
|
|
240
|
+
abort(generation.controller, error);
|
|
241
|
+
}
|
|
242
|
+
abort(waiter.controller, error);
|
|
243
|
+
rejectInert(state, waiter);
|
|
244
|
+
collect(state, generation);
|
|
245
|
+
}
|
|
246
|
+
function failGeneration(state, generation, error) {
|
|
247
|
+
retireRoute(state, generation);
|
|
248
|
+
const waiters = [...generation.waiters];
|
|
249
|
+
for (const waiter of waiters)
|
|
250
|
+
makeInert(state, waiter, error);
|
|
251
|
+
// Every waiter is inert before the first external detach or cancellation hook.
|
|
252
|
+
abort(generation.controller, error);
|
|
253
|
+
for (const waiter of waiters) {
|
|
254
|
+
abort(waiter.controller, error);
|
|
255
|
+
rejectInert(state, waiter);
|
|
256
|
+
}
|
|
257
|
+
dropResidency(state, generation);
|
|
258
|
+
collect(state, generation);
|
|
259
|
+
}
|
|
260
|
+
function install(state, waiter) {
|
|
261
|
+
const binding = waiter.signal;
|
|
262
|
+
if (binding === undefined)
|
|
263
|
+
return;
|
|
264
|
+
waiter.installing = true;
|
|
265
|
+
waiter.listening = true;
|
|
266
|
+
try {
|
|
267
|
+
APPLY(binding.add, binding.signal, ['abort', waiter.listener, FREEZE({ once: true })]);
|
|
268
|
+
if (waiter.pending) {
|
|
269
|
+
const aborted = binding.signal.aborted;
|
|
270
|
+
if (typeof aborted !== 'boolean')
|
|
271
|
+
throw new TypeError('Boolean cancellation state required');
|
|
272
|
+
if (aborted)
|
|
273
|
+
waiter.listener();
|
|
274
|
+
}
|
|
275
|
+
}
|
|
276
|
+
catch (cause) {
|
|
277
|
+
if (waiter.pending)
|
|
278
|
+
failWaiter(state, waiter, new EgretError('TEXT_SIGNAL_FAILED', { cause }));
|
|
279
|
+
else
|
|
280
|
+
recordCleanup(state, cause, 'TEXT_SIGNAL_FAILED');
|
|
281
|
+
}
|
|
282
|
+
finally {
|
|
283
|
+
waiter.installing = false;
|
|
284
|
+
}
|
|
285
|
+
if (!waiter.pending)
|
|
286
|
+
rejectInert(state, waiter);
|
|
287
|
+
}
|
|
288
|
+
function snapshotSignal(state, options) {
|
|
289
|
+
let signal;
|
|
290
|
+
let aborted;
|
|
291
|
+
let reason;
|
|
292
|
+
let add, removeMethod;
|
|
293
|
+
try {
|
|
294
|
+
if (options !== undefined && (options === null || typeof options !== 'object'))
|
|
295
|
+
throw new TypeError('Acquire options must be a record');
|
|
296
|
+
signal = options?.signal;
|
|
297
|
+
if (signal !== undefined) {
|
|
298
|
+
aborted = signal.aborted;
|
|
299
|
+
if (aborted === true)
|
|
300
|
+
reason = signal.reason;
|
|
301
|
+
else {
|
|
302
|
+
add = signal.addEventListener;
|
|
303
|
+
removeMethod = signal.removeEventListener;
|
|
304
|
+
}
|
|
305
|
+
}
|
|
306
|
+
}
|
|
307
|
+
catch (cause) {
|
|
308
|
+
assertOpen(state);
|
|
309
|
+
throw new EgretError('TEXT_SIGNAL_FAILED', { cause });
|
|
310
|
+
}
|
|
311
|
+
assertOpen(state);
|
|
312
|
+
if (signal === undefined)
|
|
313
|
+
return undefined;
|
|
314
|
+
if (typeof aborted !== 'boolean')
|
|
315
|
+
throw new EgretError('TEXT_SIGNAL_FAILED', { cause: new TypeError('Boolean cancellation state required') });
|
|
316
|
+
if (aborted)
|
|
317
|
+
throw new EgretError('TEXT_ACQUIRE_CANCELLED', { cause: reason });
|
|
318
|
+
if (typeof add !== 'function' || typeof removeMethod !== 'function')
|
|
319
|
+
throw new EgretError('TEXT_SIGNAL_FAILED', { cause: new TypeError('Cancellation methods required') });
|
|
320
|
+
return FREEZE({ signal, add: add, remove: removeMethod });
|
|
321
|
+
}
|
|
322
|
+
function commitCaller(state, waiter, lease) {
|
|
323
|
+
const generation = waiter.generation;
|
|
324
|
+
const value = readAssetLeaseValue(lease);
|
|
325
|
+
if (value !== generation.texture)
|
|
326
|
+
throw new EgretError('TEXT_RESOURCE_FAILED');
|
|
327
|
+
readTextureSnapshot(value);
|
|
328
|
+
if (lease.resourceGeneration !== generation.resourceGeneration)
|
|
329
|
+
throw new EgretError('TEXT_RESOURCE_FAILED');
|
|
330
|
+
if (!observeAssetLeaseRetirement(lease, () => {
|
|
331
|
+
generation.callers -= 1;
|
|
332
|
+
state.budget.commit({ activeCallerLeases: -1, callerLeaseSlots: -1, metadataBytes: -64 });
|
|
333
|
+
}))
|
|
334
|
+
throw new EgretError('TEXT_RESOURCE_FAILED');
|
|
335
|
+
generation.callers += 1;
|
|
336
|
+
waiter.pending = false;
|
|
337
|
+
generation.waiters.delete(waiter);
|
|
338
|
+
state.budget.commit({ pendingWaiters: -1, activeCallerLeases: 1, metadataBytes: -128 });
|
|
339
|
+
}
|
|
340
|
+
function reserveResidency(state, generation) {
|
|
341
|
+
if (state.closed ||
|
|
342
|
+
!generation.current ||
|
|
343
|
+
generation.resident ||
|
|
344
|
+
generation.residencyPending ||
|
|
345
|
+
state.budget.limits.maxResidentEntries === 0)
|
|
346
|
+
return false;
|
|
347
|
+
assertOpen(state);
|
|
348
|
+
if (state.residentLru.length >= state.budget.limits.maxResidentEntries) {
|
|
349
|
+
const oldest = state.residentLru[0];
|
|
350
|
+
if (oldest !== undefined)
|
|
351
|
+
dropResidency(state, oldest);
|
|
352
|
+
}
|
|
353
|
+
const invocation = createTextValueInvocation();
|
|
354
|
+
try {
|
|
355
|
+
state.budget.check({ residentEntries: 1, metadataBytes: 64 }, (code, cause) => createTextValueFailure(invocation, code, cause));
|
|
356
|
+
state.budget.commit({ residentEntries: 1, metadataBytes: 64 });
|
|
357
|
+
}
|
|
358
|
+
catch (cause) {
|
|
359
|
+
if (takeTextValueFailure(invocation, cause)?.code === 'TEXT_CACHE_BUDGET')
|
|
360
|
+
return false;
|
|
361
|
+
throw cause;
|
|
362
|
+
}
|
|
363
|
+
finally {
|
|
364
|
+
closeTextValueInvocation(invocation);
|
|
365
|
+
}
|
|
366
|
+
generation.residencyPending = true;
|
|
367
|
+
return true;
|
|
368
|
+
}
|
|
369
|
+
function pinResidency(state, generation, caller) {
|
|
370
|
+
try {
|
|
371
|
+
if (state.closed || !generation.current)
|
|
372
|
+
return;
|
|
373
|
+
if (caller !== undefined)
|
|
374
|
+
readTextureSnapshot(readAssetLeaseValue(caller));
|
|
375
|
+
if (!reserveResidency(state, generation))
|
|
376
|
+
return;
|
|
377
|
+
if (generation.texture === undefined) {
|
|
378
|
+
generation.residencyPending = false;
|
|
379
|
+
generation.resident = true;
|
|
380
|
+
state.residentLru.push(generation);
|
|
381
|
+
return;
|
|
382
|
+
}
|
|
383
|
+
// Retiring an older residency can run cleanup. Verify this entitlement again.
|
|
384
|
+
try {
|
|
385
|
+
assertOpen(state);
|
|
386
|
+
if (!generation.current)
|
|
387
|
+
throw new EgretError('TEXT_CACHE_CLOSED');
|
|
388
|
+
readTextureSnapshot(readAssetLeaseValue(caller));
|
|
389
|
+
}
|
|
390
|
+
catch {
|
|
391
|
+
generation.residencyPending = false;
|
|
392
|
+
state.budget.commit({ residentEntries: -1, metadataBytes: -64 });
|
|
393
|
+
return;
|
|
394
|
+
}
|
|
395
|
+
// This intrinsic acquire joins the ready entry while the verified caller is live.
|
|
396
|
+
beginActor(state, generation);
|
|
397
|
+
const promise = state.owner.acquire(generation.slot.ref);
|
|
398
|
+
void Promise.resolve(promise)
|
|
399
|
+
.then(lease => {
|
|
400
|
+
generation.residencyPending = false;
|
|
401
|
+
if (state.closed || !generation.current) {
|
|
402
|
+
state.budget.commit({ residentEntries: -1, metadataBytes: -64 });
|
|
403
|
+
release(lease);
|
|
404
|
+
return;
|
|
405
|
+
}
|
|
406
|
+
if (readAssetLeaseValue(lease) !== generation.texture ||
|
|
407
|
+
lease.resourceGeneration !== generation.resourceGeneration) {
|
|
408
|
+
release(lease);
|
|
409
|
+
throw new EgretError('TEXT_RESOURCE_FAILED');
|
|
410
|
+
}
|
|
411
|
+
if (!observeAssetLeaseRetirement(lease, () => {
|
|
412
|
+
generation.resident = false;
|
|
413
|
+
state.budget.commit({ residentEntries: -1, residentBytes: -generation.imageBytes, metadataBytes: -64 });
|
|
414
|
+
})) {
|
|
415
|
+
release(lease);
|
|
416
|
+
throw new EgretError('TEXT_RESOURCE_FAILED');
|
|
417
|
+
}
|
|
418
|
+
generation.resident = true;
|
|
419
|
+
generation.residentLease = lease;
|
|
420
|
+
state.budget.commit({ residentBytes: generation.imageBytes });
|
|
421
|
+
state.residentLru.push(generation);
|
|
422
|
+
})
|
|
423
|
+
.catch(cause => {
|
|
424
|
+
generation.residencyPending = false;
|
|
425
|
+
state.budget.commit({ residentEntries: -1, metadataBytes: -64 });
|
|
426
|
+
recordCleanup(state, cause, 'TEXT_RESOURCE_FAILED');
|
|
427
|
+
})
|
|
428
|
+
.finally(() => {
|
|
429
|
+
endActor(state, generation);
|
|
430
|
+
});
|
|
431
|
+
}
|
|
432
|
+
catch (cause) {
|
|
433
|
+
recordCleanup(state, cause, 'TEXT_RESOURCE_FAILED');
|
|
434
|
+
}
|
|
435
|
+
}
|
|
436
|
+
function deliverEmpty(state, waiter) {
|
|
437
|
+
if (!waiter.pending)
|
|
438
|
+
return;
|
|
439
|
+
const generation = waiter.generation;
|
|
440
|
+
beginActor(state, generation);
|
|
441
|
+
try {
|
|
442
|
+
waiter.pending = false;
|
|
443
|
+
generation.waiters.delete(waiter);
|
|
444
|
+
state.budget.commit({ pendingWaiters: -1, callerLeaseSlots: -1, metadataBytes: -192 });
|
|
445
|
+
const failures = detach(state, waiter);
|
|
446
|
+
if (failures.length !== 0)
|
|
447
|
+
waiter.reject(new EgretError('TEXT_SIGNAL_FAILED', { cause: failures[0] }));
|
|
448
|
+
else if (state.closed)
|
|
449
|
+
waiter.reject(new EgretError('TEXT_CACHE_CLOSED'));
|
|
450
|
+
else {
|
|
451
|
+
waiter.resolve(FREEZE({ kind: 'empty', request: generation.request, metrics: generation.metrics }));
|
|
452
|
+
pinResidency(state, generation);
|
|
453
|
+
}
|
|
454
|
+
}
|
|
455
|
+
finally {
|
|
456
|
+
endActor(state, generation);
|
|
457
|
+
}
|
|
458
|
+
}
|
|
459
|
+
function deliverImage(state, waiter) {
|
|
460
|
+
if (!waiter.pending)
|
|
461
|
+
return;
|
|
462
|
+
const generation = waiter.generation;
|
|
463
|
+
beginActor(state, generation);
|
|
464
|
+
state.staged.set(generation.slot.ref, generation);
|
|
465
|
+
let promise;
|
|
466
|
+
try {
|
|
467
|
+
promise = state.owner.acquire(generation.slot.ref, { signal: waiter.controller.signal });
|
|
468
|
+
}
|
|
469
|
+
catch (cause) {
|
|
470
|
+
state.staged.delete(generation.slot.ref);
|
|
471
|
+
failWaiter(state, waiter, new EgretError('TEXT_RESOURCE_FAILED', { cause }));
|
|
472
|
+
endActor(state, generation);
|
|
473
|
+
return;
|
|
474
|
+
}
|
|
475
|
+
state.staged.delete(generation.slot.ref);
|
|
476
|
+
void Promise.resolve(promise)
|
|
477
|
+
.then(lease => {
|
|
478
|
+
if (!waiter.pending) {
|
|
479
|
+
release(lease);
|
|
480
|
+
return;
|
|
481
|
+
}
|
|
482
|
+
try {
|
|
483
|
+
commitCaller(state, waiter, lease);
|
|
484
|
+
}
|
|
485
|
+
catch (cause) {
|
|
486
|
+
release(lease);
|
|
487
|
+
failWaiter(state, waiter, new EgretError('TEXT_RESOURCE_FAILED', { cause }));
|
|
488
|
+
return;
|
|
489
|
+
}
|
|
490
|
+
const failures = detach(state, waiter);
|
|
491
|
+
if (failures.length !== 0) {
|
|
492
|
+
release(lease);
|
|
493
|
+
waiter.reject(new EgretError('TEXT_SIGNAL_FAILED', { cause: failures[0] }));
|
|
494
|
+
return;
|
|
495
|
+
}
|
|
496
|
+
try {
|
|
497
|
+
readTextureSnapshot(readAssetLeaseValue(lease));
|
|
498
|
+
}
|
|
499
|
+
catch (cause) {
|
|
500
|
+
release(lease);
|
|
501
|
+
waiter.reject(new EgretError('TEXT_RESOURCE_FAILED', { cause }));
|
|
502
|
+
return;
|
|
503
|
+
}
|
|
504
|
+
waiter.resolve(FREEZE({ kind: 'image', request: generation.request, metrics: generation.metrics, lease }));
|
|
505
|
+
pinResidency(state, generation, lease);
|
|
506
|
+
})
|
|
507
|
+
.catch(cause => {
|
|
508
|
+
failWaiter(state, waiter, new EgretError('TEXT_RESOURCE_FAILED', { cause }));
|
|
509
|
+
})
|
|
510
|
+
.finally(() => {
|
|
511
|
+
endActor(state, generation);
|
|
512
|
+
});
|
|
513
|
+
}
|
|
514
|
+
function deliver(state, generation) {
|
|
515
|
+
for (const waiter of [...generation.waiters]) {
|
|
516
|
+
if (generation.image === undefined)
|
|
517
|
+
deliverEmpty(state, waiter);
|
|
518
|
+
else
|
|
519
|
+
deliverImage(state, waiter);
|
|
520
|
+
}
|
|
521
|
+
if (generation.image === undefined && generation.waiters.size === 0 && !generation.resident)
|
|
522
|
+
retireRoute(state, generation);
|
|
523
|
+
}
|
|
524
|
+
/** Keep exact generation identity at load entry; never resolve through the latest slot. */
|
|
525
|
+
function loadTexture(state, ref, context) {
|
|
526
|
+
const generation = state.staged.get(ref);
|
|
527
|
+
if (generation === undefined || generation.image === undefined || generation.quarantined)
|
|
528
|
+
return Promise.reject(new EgretError('TEXT_RESOURCE_FAILED'));
|
|
529
|
+
generation.resourceGeneration = context.resourceGeneration;
|
|
530
|
+
generation.taskId = context.taskId;
|
|
531
|
+
const texture = createTexture(generation.image);
|
|
532
|
+
generation.texture = texture;
|
|
533
|
+
state.textures.set(texture, generation);
|
|
534
|
+
return Promise.resolve(texture);
|
|
535
|
+
}
|
|
536
|
+
function disposeTexture(state, texture) {
|
|
537
|
+
const generation = state.textures.get(texture);
|
|
538
|
+
if (generation === undefined)
|
|
539
|
+
throw new EgretError('TEXT_RESOURCE_FAILED');
|
|
540
|
+
try {
|
|
541
|
+
APPLY(DISPOSE_TEXTURE, texture, []);
|
|
542
|
+
}
|
|
543
|
+
catch (cause) {
|
|
544
|
+
quarantine(state, generation);
|
|
545
|
+
recordCleanup(state, cause, 'TEXT_RESOURCE_FAILED', true);
|
|
546
|
+
throw cause;
|
|
547
|
+
}
|
|
548
|
+
state.textures.delete(texture);
|
|
549
|
+
generation.texture = undefined;
|
|
550
|
+
generation.image = undefined;
|
|
551
|
+
state.budget.commit({ liveImageBytes: -generation.imageBytes });
|
|
552
|
+
generation.imageBytes = 0;
|
|
553
|
+
retireRoute(state, generation);
|
|
554
|
+
collect(state, generation);
|
|
555
|
+
}
|
|
556
|
+
async function runJob(state, generation) {
|
|
557
|
+
const invocation = createTextValueInvocation();
|
|
558
|
+
const issuer = createTextRasterPlanIssuer(generation.request, invocation);
|
|
559
|
+
let plan;
|
|
560
|
+
let primary;
|
|
561
|
+
let releaseFailed = false;
|
|
562
|
+
let failedWaiters = [];
|
|
563
|
+
let lateProviderRejected = false;
|
|
564
|
+
try {
|
|
565
|
+
let returned;
|
|
566
|
+
try {
|
|
567
|
+
returned = await Promise.resolve(APPLY(state.provider.measure, state.provider.receiver, [
|
|
568
|
+
generation.request,
|
|
569
|
+
FREEZE({
|
|
570
|
+
signal: generation.controller.signal,
|
|
571
|
+
fontGeneration: generation.request.fontGeneration,
|
|
572
|
+
limits: LIMITS,
|
|
573
|
+
createPlan: issuer.createPlan
|
|
574
|
+
})
|
|
575
|
+
]));
|
|
576
|
+
}
|
|
577
|
+
catch (cause) {
|
|
578
|
+
const own = takeTextValueFailure(invocation, cause);
|
|
579
|
+
lateProviderRejected = own === undefined && (!generation.current || generation.waiters.size === 0);
|
|
580
|
+
primary = own?.error ?? new EgretError('TEXT_MEASURE_FAILED', { cause });
|
|
581
|
+
}
|
|
582
|
+
finally {
|
|
583
|
+
closeTextRasterPlanIssuer(issuer);
|
|
584
|
+
}
|
|
585
|
+
if (primary === undefined) {
|
|
586
|
+
try {
|
|
587
|
+
plan = requireIssuedTextRasterPlan(issuer, returned, invocation);
|
|
588
|
+
}
|
|
589
|
+
catch (cause) {
|
|
590
|
+
primary = takeTextValueFailure(invocation, cause)?.error ?? new EgretError('TEXT_PLAN_INVALID', { cause });
|
|
591
|
+
}
|
|
592
|
+
}
|
|
593
|
+
plan ??= readIssuedTextRasterPlan(issuer);
|
|
594
|
+
closeTextValueInvocation(invocation);
|
|
595
|
+
if (primary === undefined &&
|
|
596
|
+
plan !== undefined &&
|
|
597
|
+
generation.current &&
|
|
598
|
+
generation.waiters.size !== 0 &&
|
|
599
|
+
!state.closed) {
|
|
600
|
+
// Engine closing can precede its automatic manager-close hook at a frame barrier.
|
|
601
|
+
try {
|
|
602
|
+
assertOpen(state);
|
|
603
|
+
}
|
|
604
|
+
catch (cause) {
|
|
605
|
+
primary = cause;
|
|
606
|
+
}
|
|
607
|
+
if (primary === undefined) {
|
|
608
|
+
const bytes = plan.metrics.raster?.byteLength ?? 0;
|
|
609
|
+
const reserve = createTextValueInvocation();
|
|
610
|
+
try {
|
|
611
|
+
state.budget.check({ reservedImageBytes: bytes, pendingRasterBytes: 2 * bytes }, (code, cause) => createTextValueFailure(reserve, code, cause));
|
|
612
|
+
state.budget.commit({ reservedImageBytes: bytes, pendingRasterBytes: 2 * bytes });
|
|
613
|
+
generation.reservedBytes = bytes;
|
|
614
|
+
generation.scratchBytes = 2 * bytes;
|
|
615
|
+
}
|
|
616
|
+
catch (cause) {
|
|
617
|
+
primary = takeTextValueFailure(reserve, cause)?.error ?? new EgretError('TEXT_RASTER_FAILED', { cause });
|
|
618
|
+
}
|
|
619
|
+
finally {
|
|
620
|
+
closeTextValueInvocation(reserve);
|
|
621
|
+
}
|
|
622
|
+
if (primary === undefined) {
|
|
623
|
+
let image;
|
|
624
|
+
try {
|
|
625
|
+
image = await Promise.resolve(APPLY(state.provider.rasterize, state.provider.receiver, [
|
|
626
|
+
plan,
|
|
627
|
+
FREEZE({
|
|
628
|
+
signal: generation.controller.signal,
|
|
629
|
+
fontGeneration: generation.request.fontGeneration,
|
|
630
|
+
limits: LIMITS,
|
|
631
|
+
reservedImageBytes: bytes,
|
|
632
|
+
reservedScratchBytes: 2 * bytes
|
|
633
|
+
})
|
|
634
|
+
]));
|
|
635
|
+
}
|
|
636
|
+
catch (cause) {
|
|
637
|
+
lateProviderRejected = !generation.current || generation.waiters.size === 0;
|
|
638
|
+
primary = new EgretError('TEXT_RASTER_FAILED', { cause });
|
|
639
|
+
}
|
|
640
|
+
if (primary === undefined) {
|
|
641
|
+
if (plan.metrics.raster === undefined) {
|
|
642
|
+
if (image !== undefined)
|
|
643
|
+
primary = new EgretError('TEXT_RASTER_RESULT_INVALID');
|
|
644
|
+
}
|
|
645
|
+
else if (!isImageData2D(image))
|
|
646
|
+
primary = new EgretError('TEXT_RASTER_RESULT_INVALID');
|
|
647
|
+
else if (image.width !== plan.metrics.raster.width ||
|
|
648
|
+
image.height !== plan.metrics.raster.height ||
|
|
649
|
+
image.format !== 'rgba8unorm' ||
|
|
650
|
+
image.colorSpace !== 'srgb' ||
|
|
651
|
+
image.alphaMode !== 'straight' ||
|
|
652
|
+
image.origin !== 'top-left') {
|
|
653
|
+
primary = new EgretError('TEXT_RASTER_RESULT_INVALID');
|
|
654
|
+
}
|
|
655
|
+
else
|
|
656
|
+
generation.image = image;
|
|
657
|
+
}
|
|
658
|
+
}
|
|
659
|
+
}
|
|
660
|
+
}
|
|
661
|
+
if (primary !== undefined) {
|
|
662
|
+
// Preserve the settled primary before a release callback can close or invalidate.
|
|
663
|
+
// Reply only after release settles so a cleanup fault remains associated.
|
|
664
|
+
failedWaiters = [...generation.waiters];
|
|
665
|
+
retireRoute(state, generation);
|
|
666
|
+
for (const waiter of failedWaiters)
|
|
667
|
+
makeInert(state, waiter, primary);
|
|
668
|
+
}
|
|
669
|
+
if (plan !== undefined) {
|
|
670
|
+
// One invocation after all measure/raster uses settle, including late cancellation.
|
|
671
|
+
try {
|
|
672
|
+
await Promise.resolve(APPLY(state.provider.release, state.provider.receiver, [plan]));
|
|
673
|
+
}
|
|
674
|
+
catch (cause) {
|
|
675
|
+
releaseFailed = true;
|
|
676
|
+
generation.quarantinedPlan = plan;
|
|
677
|
+
recordCleanup(state, cause, 'TEXT_PLAN_RELEASE_FAILED');
|
|
678
|
+
quarantine(state, generation);
|
|
679
|
+
primary =
|
|
680
|
+
primary === undefined ? new EgretError('TEXT_PLAN_RELEASE_FAILED', { cause }) : associate(primary, [cause]);
|
|
681
|
+
}
|
|
682
|
+
}
|
|
683
|
+
if (primary !== undefined) {
|
|
684
|
+
for (const waiter of failedWaiters)
|
|
685
|
+
waiter.error = primary;
|
|
686
|
+
}
|
|
687
|
+
if (!releaseFailed) {
|
|
688
|
+
state.budget.commit({ pendingRasterBytes: -generation.scratchBytes });
|
|
689
|
+
generation.scratchBytes = 0;
|
|
690
|
+
}
|
|
691
|
+
if (primary !== undefined) {
|
|
692
|
+
if (lateProviderRejected) {
|
|
693
|
+
if (state.budget.snapshot().lateProviderFailureCount < Number.MAX_SAFE_INTEGER)
|
|
694
|
+
state.budget.commit({ lateProviderFailureCount: 1 });
|
|
695
|
+
}
|
|
696
|
+
failGeneration(state, generation, primary);
|
|
697
|
+
for (const waiter of failedWaiters) {
|
|
698
|
+
abort(waiter.controller, primary);
|
|
699
|
+
rejectInert(state, waiter);
|
|
700
|
+
}
|
|
701
|
+
}
|
|
702
|
+
else if (!generation.current || generation.waiters.size === 0 || state.closed) {
|
|
703
|
+
retireRoute(state, generation);
|
|
704
|
+
}
|
|
705
|
+
else {
|
|
706
|
+
// An observed release thenable may settle before the Engine frame barrier
|
|
707
|
+
// closes its manager. Preserve this trusted owner-close reason directly.
|
|
708
|
+
let ownerClose;
|
|
709
|
+
try {
|
|
710
|
+
assertOpen(state);
|
|
711
|
+
}
|
|
712
|
+
catch (cause) {
|
|
713
|
+
ownerClose = cause;
|
|
714
|
+
}
|
|
715
|
+
if (ownerClose !== undefined)
|
|
716
|
+
failGeneration(state, generation, ownerClose);
|
|
717
|
+
else {
|
|
718
|
+
generation.metrics = plan.metrics;
|
|
719
|
+
generation.kind = 'ready';
|
|
720
|
+
if (generation.image !== undefined) {
|
|
721
|
+
generation.imageBytes = generation.reservedBytes;
|
|
722
|
+
state.budget.commit({ reservedImageBytes: -generation.reservedBytes, liveImageBytes: generation.imageBytes });
|
|
723
|
+
generation.reservedBytes = 0;
|
|
724
|
+
}
|
|
725
|
+
deliver(state, generation);
|
|
726
|
+
}
|
|
727
|
+
}
|
|
728
|
+
}
|
|
729
|
+
catch (cause) {
|
|
730
|
+
failGeneration(state, generation, new EgretError('TEXT_RESOURCE_FAILED', { cause }));
|
|
731
|
+
}
|
|
732
|
+
finally {
|
|
733
|
+
closeTextValueInvocation(invocation);
|
|
734
|
+
if (!generation.quarantined && generation.texture === undefined) {
|
|
735
|
+
generation.image = undefined;
|
|
736
|
+
state.budget.commit({
|
|
737
|
+
reservedImageBytes: -generation.reservedBytes,
|
|
738
|
+
liveImageBytes: -generation.imageBytes,
|
|
739
|
+
pendingRasterBytes: -generation.scratchBytes
|
|
740
|
+
});
|
|
741
|
+
generation.reservedBytes = 0;
|
|
742
|
+
generation.imageBytes = 0;
|
|
743
|
+
generation.scratchBytes = 0;
|
|
744
|
+
}
|
|
745
|
+
generation.workSettled = true;
|
|
746
|
+
endActor(state, generation);
|
|
747
|
+
}
|
|
748
|
+
}
|
|
749
|
+
function acquire(input, options) {
|
|
750
|
+
return new Promise((resolve, reject) => {
|
|
751
|
+
const invocation = createTextValueInvocation();
|
|
752
|
+
let state;
|
|
753
|
+
let waiter;
|
|
754
|
+
let newJob = false;
|
|
755
|
+
let ownsBusy = false;
|
|
756
|
+
let createdGeneration;
|
|
757
|
+
let workActorStarted = false;
|
|
758
|
+
let constructingWaiter = false;
|
|
759
|
+
try {
|
|
760
|
+
state = stateOf(this);
|
|
761
|
+
assertMutable(state);
|
|
762
|
+
state.busy = true;
|
|
763
|
+
ownsBusy = true;
|
|
764
|
+
const binding = snapshotSignal(state, options);
|
|
765
|
+
let snapshot;
|
|
766
|
+
try {
|
|
767
|
+
snapshot = snapshotTextRasterRequest(input, invocation);
|
|
768
|
+
}
|
|
769
|
+
finally {
|
|
770
|
+
assertOpen(state);
|
|
771
|
+
}
|
|
772
|
+
let summary = summarizeTextRasterRequest(snapshot, state.provider.identity, state.fontGeneration, invocation);
|
|
773
|
+
// Count refusal precedes any optional route retirement and external cleanup.
|
|
774
|
+
state.budget.check({ pendingWaiters: 1, callerLeaseSlots: 1 }, (code, cause) => createTextValueFailure(invocation, code, cause));
|
|
775
|
+
let generation = state.lru.find(value => matchesTextRasterRequestSummary(value.request, summary, state.provider.identity, state.fontGeneration));
|
|
776
|
+
if (generation?.texture !== undefined) {
|
|
777
|
+
try {
|
|
778
|
+
readTextureSnapshot(generation.texture);
|
|
779
|
+
}
|
|
780
|
+
catch {
|
|
781
|
+
retire(state, generation, true);
|
|
782
|
+
generation = undefined;
|
|
783
|
+
}
|
|
784
|
+
}
|
|
785
|
+
let slot;
|
|
786
|
+
if (generation === undefined) {
|
|
787
|
+
slot = state.slots.find(value => value.current === undefined);
|
|
788
|
+
if (slot === undefined) {
|
|
789
|
+
const oldest = state.lru.find(value => value.kind === 'ready');
|
|
790
|
+
if (oldest !== undefined) {
|
|
791
|
+
slot = oldest.slot;
|
|
792
|
+
retire(state, oldest, true);
|
|
793
|
+
}
|
|
794
|
+
}
|
|
795
|
+
}
|
|
796
|
+
// Caller limits precede route/generation/job limits for the same proposal.
|
|
797
|
+
if (generation === undefined) {
|
|
798
|
+
if (slot === undefined)
|
|
799
|
+
throw createTextValueFailure(invocation, 'TEXT_CACHE_BUDGET');
|
|
800
|
+
const sequence = increment(slot.sequence);
|
|
801
|
+
state.budget.check({
|
|
802
|
+
pendingWaiters: 1,
|
|
803
|
+
callerLeaseSlots: 1,
|
|
804
|
+
occupiedSlots: 1,
|
|
805
|
+
currentGenerations: 1,
|
|
806
|
+
pendingJobs: 1,
|
|
807
|
+
metadataBytes: summary.metadataBytes + 192
|
|
808
|
+
}, (code, cause) => createTextValueFailure(invocation, code, cause));
|
|
809
|
+
// Owned source-line arrays are covered before their first allocation.
|
|
810
|
+
state.budget.commit({ metadataBytes: summary.metadataBytes });
|
|
811
|
+
try {
|
|
812
|
+
const request = createOwnedTextRasterRequest(summary, invocation);
|
|
813
|
+
generation = {
|
|
814
|
+
slot,
|
|
815
|
+
sequence,
|
|
816
|
+
request,
|
|
817
|
+
metadata: summary.metadataBytes,
|
|
818
|
+
controller: controller(state),
|
|
819
|
+
waiters: new Set(),
|
|
820
|
+
current: true,
|
|
821
|
+
kind: 'loading',
|
|
822
|
+
actors: 0,
|
|
823
|
+
jobCharged: true,
|
|
824
|
+
workSettled: false,
|
|
825
|
+
quarantined: false,
|
|
826
|
+
quarantinedPlan: undefined,
|
|
827
|
+
callers: 0,
|
|
828
|
+
metrics: undefined,
|
|
829
|
+
image: undefined,
|
|
830
|
+
texture: undefined,
|
|
831
|
+
imageBytes: 0,
|
|
832
|
+
reservedBytes: 0,
|
|
833
|
+
scratchBytes: 0,
|
|
834
|
+
resourceGeneration: undefined,
|
|
835
|
+
taskId: undefined,
|
|
836
|
+
resident: false,
|
|
837
|
+
residentLease: undefined,
|
|
838
|
+
residencyPending: false
|
|
839
|
+
};
|
|
840
|
+
// A free route may still have real callers from a retired manager generation.
|
|
841
|
+
state.owner.invalidate(slot.ref);
|
|
842
|
+
}
|
|
843
|
+
catch (cause) {
|
|
844
|
+
state.budget.commit({ metadataBytes: -summary.metadataBytes });
|
|
845
|
+
throw new EgretError('TEXT_REQUEST_INVALID', { cause });
|
|
846
|
+
}
|
|
847
|
+
state.budget.commit({ occupiedSlots: 1, currentGenerations: 1, pendingJobs: 1 });
|
|
848
|
+
slot.sequence = sequence;
|
|
849
|
+
slot.current = generation;
|
|
850
|
+
state.generations.add(generation);
|
|
851
|
+
touch(state, generation);
|
|
852
|
+
newJob = true;
|
|
853
|
+
createdGeneration = generation;
|
|
854
|
+
}
|
|
855
|
+
else {
|
|
856
|
+
state.budget.check({ pendingWaiters: 1, callerLeaseSlots: 1, metadataBytes: 192 }, (code, cause) => createTextValueFailure(invocation, code, cause));
|
|
857
|
+
touch(state, generation);
|
|
858
|
+
}
|
|
859
|
+
snapshot = undefined;
|
|
860
|
+
summary = undefined;
|
|
861
|
+
const ownedState = state;
|
|
862
|
+
const ownedGeneration = generation;
|
|
863
|
+
constructingWaiter = true;
|
|
864
|
+
waiter = {
|
|
865
|
+
generation,
|
|
866
|
+
signal: binding,
|
|
867
|
+
controller: controller(state),
|
|
868
|
+
pending: true,
|
|
869
|
+
installing: false,
|
|
870
|
+
listening: false,
|
|
871
|
+
error: undefined,
|
|
872
|
+
resolve,
|
|
873
|
+
reject,
|
|
874
|
+
listener: () => {
|
|
875
|
+
if (!waiter.pending)
|
|
876
|
+
return;
|
|
877
|
+
let reason;
|
|
878
|
+
try {
|
|
879
|
+
reason = binding.signal.reason;
|
|
880
|
+
}
|
|
881
|
+
catch (cause) {
|
|
882
|
+
failWaiter(ownedState, waiter, new EgretError('TEXT_SIGNAL_FAILED', { cause }));
|
|
883
|
+
return;
|
|
884
|
+
}
|
|
885
|
+
failWaiter(ownedState, waiter, new EgretError('TEXT_ACQUIRE_CANCELLED', { cause: reason }));
|
|
886
|
+
}
|
|
887
|
+
};
|
|
888
|
+
constructingWaiter = false;
|
|
889
|
+
state.budget.commit({ pendingWaiters: 1, callerLeaseSlots: 1, metadataBytes: 192 });
|
|
890
|
+
generation.waiters.add(waiter);
|
|
891
|
+
if (newJob) {
|
|
892
|
+
beginActor(state, generation);
|
|
893
|
+
workActorStarted = true;
|
|
894
|
+
}
|
|
895
|
+
state.busy = false;
|
|
896
|
+
closeTextValueInvocation(invocation);
|
|
897
|
+
beginActor(state, generation);
|
|
898
|
+
try {
|
|
899
|
+
install(state, waiter);
|
|
900
|
+
// Hand off while installation is still an actor; an idle observer must
|
|
901
|
+
// never see a gap before actual delivery and external listener removal.
|
|
902
|
+
if (newJob) {
|
|
903
|
+
if (!ownedGeneration.current || ownedGeneration.waiters.size === 0) {
|
|
904
|
+
ownedGeneration.workSettled = true;
|
|
905
|
+
endActor(state, ownedGeneration);
|
|
906
|
+
}
|
|
907
|
+
else
|
|
908
|
+
void runJob(state, ownedGeneration);
|
|
909
|
+
}
|
|
910
|
+
else if (waiter.pending && generation.kind === 'ready') {
|
|
911
|
+
if (generation.image === undefined)
|
|
912
|
+
deliverEmpty(state, waiter);
|
|
913
|
+
else
|
|
914
|
+
deliverImage(state, waiter);
|
|
915
|
+
}
|
|
916
|
+
}
|
|
917
|
+
finally {
|
|
918
|
+
endActor(state, generation);
|
|
919
|
+
}
|
|
920
|
+
}
|
|
921
|
+
catch (cause) {
|
|
922
|
+
const own = takeTextValueFailure(invocation, cause);
|
|
923
|
+
if (waiter !== undefined && state !== undefined)
|
|
924
|
+
failWaiter(state, waiter, own?.error ?? new EgretError('TEXT_RESOURCE_FAILED', { cause }));
|
|
925
|
+
else
|
|
926
|
+
reject(own?.error ?? (constructingWaiter ? new EgretError('TEXT_REQUEST_INVALID', { cause }) : cause));
|
|
927
|
+
if (state !== undefined && createdGeneration !== undefined && !workActorStarted) {
|
|
928
|
+
// No provider/async actor used the record. Undo its undemanded admission.
|
|
929
|
+
retireRoute(state, createdGeneration);
|
|
930
|
+
createdGeneration.workSettled = true;
|
|
931
|
+
if (createdGeneration.jobCharged) {
|
|
932
|
+
createdGeneration.jobCharged = false;
|
|
933
|
+
state.budget.commit({ pendingJobs: -1 });
|
|
934
|
+
}
|
|
935
|
+
collect(state, createdGeneration);
|
|
936
|
+
}
|
|
937
|
+
}
|
|
938
|
+
finally {
|
|
939
|
+
if (state !== undefined && ownsBusy)
|
|
940
|
+
state.busy = false;
|
|
941
|
+
closeTextValueInvocation(invocation);
|
|
942
|
+
}
|
|
943
|
+
});
|
|
944
|
+
}
|
|
945
|
+
function invalidate() {
|
|
946
|
+
const state = stateOf(this);
|
|
947
|
+
assertMutable(state);
|
|
948
|
+
const next = increment(state.fontGeneration);
|
|
949
|
+
state.fontGeneration = next;
|
|
950
|
+
const current = [...state.lru];
|
|
951
|
+
const error = new EgretError('TEXT_ACQUIRE_CANCELLED');
|
|
952
|
+
const waiters = current.flatMap(generation => [...generation.waiters]);
|
|
953
|
+
for (const generation of current)
|
|
954
|
+
retireRoute(state, generation);
|
|
955
|
+
for (const waiter of waiters)
|
|
956
|
+
makeInert(state, waiter, error);
|
|
957
|
+
for (const generation of current)
|
|
958
|
+
state.owner.invalidate(generation.slot.ref);
|
|
959
|
+
for (const generation of current) {
|
|
960
|
+
abort(generation.controller, error);
|
|
961
|
+
dropResidency(state, generation);
|
|
962
|
+
collect(state, generation);
|
|
963
|
+
}
|
|
964
|
+
for (const waiter of waiters) {
|
|
965
|
+
abort(waiter.controller, error);
|
|
966
|
+
rejectInert(state, waiter);
|
|
967
|
+
}
|
|
968
|
+
}
|
|
969
|
+
function close(state) {
|
|
970
|
+
if (state.closed)
|
|
971
|
+
return;
|
|
972
|
+
state.closed = true;
|
|
973
|
+
const error = new EgretError('TEXT_CACHE_CLOSED');
|
|
974
|
+
const generations = [...state.generations];
|
|
975
|
+
const waiters = generations.flatMap(generation => [...generation.waiters]);
|
|
976
|
+
for (const generation of generations)
|
|
977
|
+
retireRoute(state, generation);
|
|
978
|
+
for (const waiter of waiters)
|
|
979
|
+
makeInert(state, waiter, error);
|
|
980
|
+
for (const generation of generations) {
|
|
981
|
+
abort(generation.controller, error);
|
|
982
|
+
dropResidency(state, generation);
|
|
983
|
+
collect(state, generation);
|
|
984
|
+
}
|
|
985
|
+
for (const waiter of waiters) {
|
|
986
|
+
abort(waiter.controller, error);
|
|
987
|
+
rejectInert(state, waiter);
|
|
988
|
+
}
|
|
989
|
+
settleIdle(state);
|
|
990
|
+
}
|
|
991
|
+
function dispose() {
|
|
992
|
+
close(stateOf(this));
|
|
993
|
+
}
|
|
994
|
+
function getStatus() {
|
|
995
|
+
const state = stateOf(this);
|
|
996
|
+
return FREEZE({ closed: state.closed, fontGeneration: state.fontGeneration, ...state.budget.snapshot() });
|
|
997
|
+
}
|
|
998
|
+
function whenIdle() {
|
|
999
|
+
return new Promise((resolve, reject) => {
|
|
1000
|
+
const invocation = createTextValueInvocation();
|
|
1001
|
+
try {
|
|
1002
|
+
const state = stateOf(this);
|
|
1003
|
+
if (state.actors === 0) {
|
|
1004
|
+
if (state.hasCleanupFailure)
|
|
1005
|
+
reject(new EgretError('TEXT_CACHE_CLEANUP_FAILED', { cause: state.firstCleanupCause }));
|
|
1006
|
+
else
|
|
1007
|
+
resolve();
|
|
1008
|
+
return;
|
|
1009
|
+
}
|
|
1010
|
+
state.budget.check({ idleWaiters: 1, metadataBytes: 64 }, (code, cause) => createTextValueFailure(invocation, code, cause));
|
|
1011
|
+
const waiter = { resolve, reject };
|
|
1012
|
+
state.budget.commit({ idleWaiters: 1, metadataBytes: 64 });
|
|
1013
|
+
state.idle.add(waiter);
|
|
1014
|
+
}
|
|
1015
|
+
catch (cause) {
|
|
1016
|
+
reject(takeTextValueFailure(invocation, cause)?.error ?? cause);
|
|
1017
|
+
}
|
|
1018
|
+
finally {
|
|
1019
|
+
closeTextValueInvocation(invocation);
|
|
1020
|
+
}
|
|
1021
|
+
});
|
|
1022
|
+
}
|
|
1023
|
+
/** Explicit CPU text orchestration; this entry owns no browser font or drawing surface. */
|
|
1024
|
+
export function createTextRasterCache(assets, options) {
|
|
1025
|
+
const owner = requireAssetManagerOwner(assets);
|
|
1026
|
+
let finish;
|
|
1027
|
+
try {
|
|
1028
|
+
finish = beginTextCacheCreation(assets);
|
|
1029
|
+
}
|
|
1030
|
+
catch (cause) {
|
|
1031
|
+
// The authentic lifetime seam supplies these exact synchronous guard failures.
|
|
1032
|
+
if (cause instanceof EgretError &&
|
|
1033
|
+
(cause.code === 'TEXT_CACHE_ALREADY_CREATED' || cause.code === 'TEXT_CACHE_REENTRANT'))
|
|
1034
|
+
throw cause;
|
|
1035
|
+
throw new EgretError('TEXT_CACHE_CLOSED', { cause });
|
|
1036
|
+
}
|
|
1037
|
+
try {
|
|
1038
|
+
let values;
|
|
1039
|
+
try {
|
|
1040
|
+
if (options === null || typeof options !== 'object')
|
|
1041
|
+
throw new TypeError('Text cache options required');
|
|
1042
|
+
values = [
|
|
1043
|
+
options.provider,
|
|
1044
|
+
options.maxGenerations,
|
|
1045
|
+
options.maxPendingJobs,
|
|
1046
|
+
options.maxWaiters,
|
|
1047
|
+
options.maxCallerLeases,
|
|
1048
|
+
options.maxResidentEntries,
|
|
1049
|
+
options.maxMetadataBytes,
|
|
1050
|
+
options.maxLogicalImageBytes,
|
|
1051
|
+
options.maxPendingRasterBytes
|
|
1052
|
+
];
|
|
1053
|
+
}
|
|
1054
|
+
catch (cause) {
|
|
1055
|
+
try {
|
|
1056
|
+
owner.assertOpen();
|
|
1057
|
+
}
|
|
1058
|
+
catch (closed) {
|
|
1059
|
+
throw new EgretError('TEXT_CACHE_CLOSED', { cause: closed });
|
|
1060
|
+
}
|
|
1061
|
+
throw new EgretError('TEXT_CACHE_OPTIONS_INVALID', { cause });
|
|
1062
|
+
}
|
|
1063
|
+
let providerValues;
|
|
1064
|
+
const receiver = values[0];
|
|
1065
|
+
try {
|
|
1066
|
+
if (receiver === null || (typeof receiver !== 'object' && typeof receiver !== 'function'))
|
|
1067
|
+
throw new TypeError('Text provider required');
|
|
1068
|
+
providerValues = [receiver.identity, receiver.profile, receiver.measure, receiver.rasterize, receiver.release];
|
|
1069
|
+
}
|
|
1070
|
+
catch (cause) {
|
|
1071
|
+
try {
|
|
1072
|
+
owner.assertOpen();
|
|
1073
|
+
}
|
|
1074
|
+
catch (closed) {
|
|
1075
|
+
throw new EgretError('TEXT_CACHE_CLOSED', { cause: closed });
|
|
1076
|
+
}
|
|
1077
|
+
throw new EgretError('TEXT_PROVIDER_INVALID', { cause });
|
|
1078
|
+
}
|
|
1079
|
+
try {
|
|
1080
|
+
owner.assertOpen();
|
|
1081
|
+
}
|
|
1082
|
+
catch (cause) {
|
|
1083
|
+
throw new EgretError('TEXT_CACHE_CLOSED', { cause });
|
|
1084
|
+
}
|
|
1085
|
+
const [identity, profile, measure, rasterize, releasePlan] = providerValues;
|
|
1086
|
+
const match = typeof identity === 'string'
|
|
1087
|
+
? APPLY(REGEXP_EXEC, PROVIDER_IDENTITY, [identity])
|
|
1088
|
+
: null;
|
|
1089
|
+
if (match === null ||
|
|
1090
|
+
match[0].length !== identity.length ||
|
|
1091
|
+
profile !== PROFILE ||
|
|
1092
|
+
typeof measure !== 'function' ||
|
|
1093
|
+
typeof rasterize !== 'function' ||
|
|
1094
|
+
typeof releasePlan !== 'function')
|
|
1095
|
+
throw new EgretError('TEXT_PROVIDER_INVALID');
|
|
1096
|
+
const limits = { ...TEXT_BUDGET_DEFAULTS };
|
|
1097
|
+
const mutable = limits;
|
|
1098
|
+
let index = 1;
|
|
1099
|
+
for (const key of LIMIT_KEYS) {
|
|
1100
|
+
const supplied = values[index++];
|
|
1101
|
+
const value = supplied === undefined ? TEXT_BUDGET_DEFAULTS[key] : supplied;
|
|
1102
|
+
if (typeof value !== 'number' ||
|
|
1103
|
+
!SAFE_INTEGER(value) ||
|
|
1104
|
+
value < TEXT_BUDGET_MINIMA[key] ||
|
|
1105
|
+
value > TEXT_BUDGET_DEFAULTS[key])
|
|
1106
|
+
throw new EgretError('TEXT_CACHE_OPTIONS_INVALID');
|
|
1107
|
+
mutable[key] = value === 0 ? 0 : value;
|
|
1108
|
+
}
|
|
1109
|
+
const type = createAssetType('egret.text-raster.t1.texture', isTexture);
|
|
1110
|
+
const slots = FREEZE(Array.from({ length: 32 }, (_, index) => ({
|
|
1111
|
+
ref: createAssetRef(type, `egret.text-raster.t1.slot.${String(index).padStart(2, '0')}`),
|
|
1112
|
+
sequence: 0,
|
|
1113
|
+
current: undefined
|
|
1114
|
+
})));
|
|
1115
|
+
const state = {
|
|
1116
|
+
owner,
|
|
1117
|
+
provider: FREEZE({
|
|
1118
|
+
receiver,
|
|
1119
|
+
identity: identity,
|
|
1120
|
+
measure: measure,
|
|
1121
|
+
rasterize: rasterize,
|
|
1122
|
+
release: releasePlan
|
|
1123
|
+
}),
|
|
1124
|
+
budget: new TextBudget(FREEZE(limits)),
|
|
1125
|
+
slots,
|
|
1126
|
+
generations: new Set(),
|
|
1127
|
+
lru: [],
|
|
1128
|
+
residentLru: [],
|
|
1129
|
+
staged: new Map(),
|
|
1130
|
+
textures: new WeakMap(),
|
|
1131
|
+
idle: new Set(),
|
|
1132
|
+
closed: false,
|
|
1133
|
+
busy: false,
|
|
1134
|
+
fontGeneration: 1,
|
|
1135
|
+
actors: 0,
|
|
1136
|
+
hasCleanupFailure: false,
|
|
1137
|
+
firstCleanupCause: undefined
|
|
1138
|
+
};
|
|
1139
|
+
const cache = FREEZE({ profile: PROFILE, acquire, invalidate, getStatus, whenIdle, dispose });
|
|
1140
|
+
APPLY(WEAK_SET, states, [cache, state]);
|
|
1141
|
+
commitBinding([cache], owner.context);
|
|
1142
|
+
commitTextCacheLifetime(assets, () => {
|
|
1143
|
+
close(state);
|
|
1144
|
+
});
|
|
1145
|
+
try {
|
|
1146
|
+
owner.register(type, {
|
|
1147
|
+
load: (ref, context) => loadTexture(state, ref, context),
|
|
1148
|
+
dispose: texture => {
|
|
1149
|
+
disposeTexture(state, texture);
|
|
1150
|
+
}
|
|
1151
|
+
});
|
|
1152
|
+
for (const slot of slots)
|
|
1153
|
+
owner.invalidate(slot.ref);
|
|
1154
|
+
}
|
|
1155
|
+
catch (cause) {
|
|
1156
|
+
close(state);
|
|
1157
|
+
throw new EgretError('TEXT_CACHE_NAMESPACE_FAILED', { cause });
|
|
1158
|
+
}
|
|
1159
|
+
// Only the genuine manager's hidden context can register this exact cache.
|
|
1160
|
+
owner.context.registerTextFieldCache?.(cache, scope => createTextFieldLeaf(scope, FREEZE({
|
|
1161
|
+
context: owner.context,
|
|
1162
|
+
assertOpen: () => {
|
|
1163
|
+
assertOpen(state);
|
|
1164
|
+
},
|
|
1165
|
+
adopt: (input, revalidate) => {
|
|
1166
|
+
const invocation = createTextValueInvocation();
|
|
1167
|
+
try {
|
|
1168
|
+
const snapshot = snapshotTextRasterRequest(input, invocation);
|
|
1169
|
+
revalidate();
|
|
1170
|
+
const summary = summarizeTextRasterRequest(snapshot, state.provider.identity, state.fontGeneration, invocation);
|
|
1171
|
+
return createTextFieldRequestInput(summary, invocation);
|
|
1172
|
+
}
|
|
1173
|
+
catch (cause) {
|
|
1174
|
+
const failure = takeTextValueFailure(invocation, cause);
|
|
1175
|
+
if (failure !== undefined)
|
|
1176
|
+
throw failure.error;
|
|
1177
|
+
throw cause;
|
|
1178
|
+
}
|
|
1179
|
+
finally {
|
|
1180
|
+
closeTextValueInvocation(invocation);
|
|
1181
|
+
}
|
|
1182
|
+
},
|
|
1183
|
+
acquire: (input, signal) => APPLY(acquire, cache, [input, { signal }])
|
|
1184
|
+
})));
|
|
1185
|
+
return cache;
|
|
1186
|
+
}
|
|
1187
|
+
finally {
|
|
1188
|
+
finish();
|
|
1189
|
+
}
|
|
1190
|
+
}
|
|
1191
|
+
//# sourceMappingURL=TextRasterCache.js.map
|