@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,354 @@
|
|
|
1
|
+
// SPDX-License-Identifier: Apache-2.0
|
|
2
|
+
import { createImageData2D } from '@egret/contracts';
|
|
3
|
+
import { observeAssetLeaseRetirement, readAssetLeaseValue } from '../AssetLease.js';
|
|
4
|
+
import { createAssetRef, createAssetType } from '../AssetRef.js';
|
|
5
|
+
import { EgretError } from '../EgretError.js';
|
|
6
|
+
import { createTexture, isTexture } from '../Texture.js';
|
|
7
|
+
import { beginParagraphCacheCreation, commitParagraphCacheLifetime, requireAssetManagerOwner } from '../assetManagerOwnerState.js';
|
|
8
|
+
import { commitBinding } from '../ownership.js';
|
|
9
|
+
import { createParagraphNode } from './Paragraph.js';
|
|
10
|
+
import { snapshotParagraphRequest, snapshotParagraphRaster } from './request.js';
|
|
11
|
+
import { snapshotParagraphTextGeometry } from './geometry.js';
|
|
12
|
+
const states = new WeakMap();
|
|
13
|
+
const releaseLease = (lease) => {
|
|
14
|
+
lease?.release();
|
|
15
|
+
};
|
|
16
|
+
function stateOf(cache) {
|
|
17
|
+
const s = states.get(cache);
|
|
18
|
+
if (!s)
|
|
19
|
+
throw new EgretError('PARAGRAPH_CACHE_INVALID');
|
|
20
|
+
return s;
|
|
21
|
+
}
|
|
22
|
+
function live(s) {
|
|
23
|
+
s.owner.assertOpen();
|
|
24
|
+
if (s.closed)
|
|
25
|
+
throw new EgretError('PARAGRAPH_CACHE_CLOSED');
|
|
26
|
+
}
|
|
27
|
+
function limit(value, fallback, min, max) {
|
|
28
|
+
if (value === undefined)
|
|
29
|
+
return fallback;
|
|
30
|
+
if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < min || value > max)
|
|
31
|
+
throw new EgretError('PARAGRAPH_CACHE_OPTIONS_INVALID');
|
|
32
|
+
return value;
|
|
33
|
+
}
|
|
34
|
+
function retire(s, slot) {
|
|
35
|
+
slot.key = undefined;
|
|
36
|
+
slot.request = undefined;
|
|
37
|
+
slot.result = undefined;
|
|
38
|
+
const resident = slot.resident;
|
|
39
|
+
slot.resident = undefined;
|
|
40
|
+
// Revoke the current generation before releasing residency; caller leases remain valid.
|
|
41
|
+
s.owner.invalidate(slot.ref);
|
|
42
|
+
releaseLease(resident);
|
|
43
|
+
}
|
|
44
|
+
function evictFor(s, needed, metadata, except) {
|
|
45
|
+
while (s.bytes + needed > s.maxBytes || s.geometryBytes + metadata > s.maxGeometryBytes) {
|
|
46
|
+
const candidate = s.slots
|
|
47
|
+
.filter(slot => slot !== except && slot.key !== undefined && slot.callers === 0 && !slot.residentPending)
|
|
48
|
+
.sort((a, b) => a.used - b.used)[0];
|
|
49
|
+
if (!candidate)
|
|
50
|
+
throw new EgretError('PARAGRAPH_CACHE_BUDGET');
|
|
51
|
+
retire(s, candidate);
|
|
52
|
+
}
|
|
53
|
+
}
|
|
54
|
+
function close(s) {
|
|
55
|
+
if (s.closed)
|
|
56
|
+
return;
|
|
57
|
+
s.closed = true;
|
|
58
|
+
let first, failed = false;
|
|
59
|
+
for (const slot of s.slots) {
|
|
60
|
+
// Manager shutdown already owns invalidation; explicit cache disposal still retires its refs.
|
|
61
|
+
const resident = slot.resident;
|
|
62
|
+
slot.resident = undefined;
|
|
63
|
+
slot.key = undefined;
|
|
64
|
+
slot.request = undefined;
|
|
65
|
+
slot.result = undefined;
|
|
66
|
+
try {
|
|
67
|
+
s.owner.invalidate(slot.ref);
|
|
68
|
+
}
|
|
69
|
+
catch (cause) {
|
|
70
|
+
if (!failed) {
|
|
71
|
+
first = cause;
|
|
72
|
+
failed = true;
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
try {
|
|
76
|
+
releaseLease(resident);
|
|
77
|
+
}
|
|
78
|
+
catch (cause) {
|
|
79
|
+
if (!failed) {
|
|
80
|
+
first = cause;
|
|
81
|
+
failed = true;
|
|
82
|
+
}
|
|
83
|
+
}
|
|
84
|
+
}
|
|
85
|
+
if (failed) {
|
|
86
|
+
try {
|
|
87
|
+
s.owner.assertOpen();
|
|
88
|
+
}
|
|
89
|
+
catch {
|
|
90
|
+
return;
|
|
91
|
+
}
|
|
92
|
+
throw first;
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
function checkFontSet(s, request) {
|
|
96
|
+
if (request.fontSet === undefined)
|
|
97
|
+
return;
|
|
98
|
+
if (!s.hasFontSet)
|
|
99
|
+
throw new EgretError('PARAGRAPH_FEATURE_UNSUPPORTED');
|
|
100
|
+
if (Reflect.apply(s.hasFontSet, s.provider, [request.fontSet]) !== true)
|
|
101
|
+
throw new EgretError('PARAGRAPH_FONT_SET_RETIRED');
|
|
102
|
+
live(s);
|
|
103
|
+
}
|
|
104
|
+
async function acquire(input, options = {}) {
|
|
105
|
+
const s = stateOf(this);
|
|
106
|
+
live(s);
|
|
107
|
+
const request = snapshotParagraphRequest(input), signal = options.signal;
|
|
108
|
+
live(s);
|
|
109
|
+
if (signal?.aborted)
|
|
110
|
+
throw new EgretError('PARAGRAPH_CANCELLED', { cause: signal.reason });
|
|
111
|
+
// Feature refusal happens before reserving a slot or invoking an older provider.
|
|
112
|
+
if ((request.textAlign !== undefined && !s.supportsTextAlign) ||
|
|
113
|
+
(request.maxLines !== undefined && !s.supportsMaxLines) ||
|
|
114
|
+
(request.textGeometry && !s.supportsTextGeometry) ||
|
|
115
|
+
(request.runs !== undefined && !s.supportsStyledRuns))
|
|
116
|
+
throw new EgretError('PARAGRAPH_FEATURE_UNSUPPORTED');
|
|
117
|
+
checkFontSet(s, request);
|
|
118
|
+
if (s.slots.reduce((total, slot) => total + slot.callers, 0) >= 256)
|
|
119
|
+
throw new EgretError('PARAGRAPH_CACHE_BUDGET');
|
|
120
|
+
const key = JSON.stringify(request);
|
|
121
|
+
let slot = s.slots.find(slot => slot.key === key);
|
|
122
|
+
if (!slot) {
|
|
123
|
+
slot = s.slots.find(slot => slot.key === undefined && slot.callers === 0 && !slot.residentPending);
|
|
124
|
+
if (!slot) {
|
|
125
|
+
slot = s.slots.filter(slot => slot.callers === 0 && !slot.residentPending).sort((a, b) => a.used - b.used)[0];
|
|
126
|
+
if (!slot)
|
|
127
|
+
throw new EgretError('PARAGRAPH_CACHE_BUDGET');
|
|
128
|
+
retire(s, slot);
|
|
129
|
+
}
|
|
130
|
+
slot.key = key;
|
|
131
|
+
slot.request = request;
|
|
132
|
+
}
|
|
133
|
+
const selected = slot;
|
|
134
|
+
selected.used = ++s.clock;
|
|
135
|
+
selected.callers++;
|
|
136
|
+
let lease, observed = false;
|
|
137
|
+
try {
|
|
138
|
+
lease = await s.owner.acquire(selected.ref, signal === undefined ? {} : { signal });
|
|
139
|
+
live(s);
|
|
140
|
+
if (signal?.aborted)
|
|
141
|
+
throw new EgretError('PARAGRAPH_CANCELLED', { cause: signal.reason });
|
|
142
|
+
checkFontSet(s, request);
|
|
143
|
+
const texture = readAssetLeaseValue(lease), result = s.textures.get(texture);
|
|
144
|
+
if (!result)
|
|
145
|
+
throw new EgretError('PARAGRAPH_CACHE_INVALID');
|
|
146
|
+
if (!observeAssetLeaseRetirement(lease, () => {
|
|
147
|
+
selected.callers--;
|
|
148
|
+
}))
|
|
149
|
+
throw new EgretError('PARAGRAPH_CACHE_INVALID');
|
|
150
|
+
observed = true;
|
|
151
|
+
// One bounded resident borrow keeps unchanged paragraphs out of shape/raster work.
|
|
152
|
+
if (!selected.resident && !selected.residentPending && selected.key === key && selected.result === result) {
|
|
153
|
+
selected.residentPending = true;
|
|
154
|
+
void s.owner.acquire(selected.ref).then(resident => {
|
|
155
|
+
selected.residentPending = false;
|
|
156
|
+
if (!s.closed && selected.key === key && selected.result === result)
|
|
157
|
+
selected.resident = resident;
|
|
158
|
+
else
|
|
159
|
+
resident.release();
|
|
160
|
+
}, () => {
|
|
161
|
+
selected.residentPending = false;
|
|
162
|
+
});
|
|
163
|
+
}
|
|
164
|
+
return Object.freeze({ lease, ...result.prepared });
|
|
165
|
+
}
|
|
166
|
+
catch (cause) {
|
|
167
|
+
// No observer was installed for a failed delivery.
|
|
168
|
+
if (lease)
|
|
169
|
+
lease.release();
|
|
170
|
+
if (!observed)
|
|
171
|
+
selected.callers--;
|
|
172
|
+
if (selected.callers === 0 && !selected.resident && !selected.residentPending)
|
|
173
|
+
retire(s, selected);
|
|
174
|
+
throw cause;
|
|
175
|
+
}
|
|
176
|
+
}
|
|
177
|
+
function invalidate() {
|
|
178
|
+
const s = stateOf(this);
|
|
179
|
+
live(s);
|
|
180
|
+
s.generation++;
|
|
181
|
+
for (const slot of s.slots)
|
|
182
|
+
if (slot.key !== undefined)
|
|
183
|
+
retire(s, slot);
|
|
184
|
+
}
|
|
185
|
+
function getStatus() {
|
|
186
|
+
const s = stateOf(this);
|
|
187
|
+
return Object.freeze({
|
|
188
|
+
closed: s.closed,
|
|
189
|
+
generation: s.generation,
|
|
190
|
+
entries: s.slots.filter(slot => slot.key !== undefined).length,
|
|
191
|
+
imageBytes: s.bytes,
|
|
192
|
+
geometryBytes: s.geometryBytes,
|
|
193
|
+
pendingJobs: s.jobs,
|
|
194
|
+
callerLeases: s.slots.reduce((sum, slot) => sum + slot.callers, 0)
|
|
195
|
+
});
|
|
196
|
+
}
|
|
197
|
+
function dispose() {
|
|
198
|
+
close(stateOf(this));
|
|
199
|
+
}
|
|
200
|
+
/** A fixed optional profile shares Engine/AssetManager leases and their shutdown authority. */
|
|
201
|
+
export function createParagraphCache(assets, options) {
|
|
202
|
+
const owner = requireAssetManagerOwner(assets), finish = beginParagraphCacheCreation(assets);
|
|
203
|
+
try {
|
|
204
|
+
const provider = options.provider, identity = provider.identity, prepare = provider.prepare;
|
|
205
|
+
const capabilities = provider.capabilities;
|
|
206
|
+
if (capabilities !== undefined &&
|
|
207
|
+
(capabilities === null || typeof capabilities !== 'object' || Array.isArray(capabilities)))
|
|
208
|
+
throw new EgretError('PARAGRAPH_PROVIDER_INVALID');
|
|
209
|
+
const textAlign = capabilities?.textAlign, maxLines = capabilities?.maxLines, textGeometry = capabilities?.textGeometry, styledRuns = capabilities?.styledRuns;
|
|
210
|
+
if ((textAlign !== undefined && typeof textAlign !== 'boolean') ||
|
|
211
|
+
(maxLines !== undefined && typeof maxLines !== 'boolean') ||
|
|
212
|
+
(textGeometry !== undefined && typeof textGeometry !== 'boolean') ||
|
|
213
|
+
(styledRuns !== undefined && typeof styledRuns !== 'boolean'))
|
|
214
|
+
throw new EgretError('PARAGRAPH_PROVIDER_INVALID');
|
|
215
|
+
const supportsTextAlign = textAlign === true, supportsMaxLines = maxLines === true, supportsTextGeometry = textGeometry === true, supportsStyledRuns = styledRuns === true;
|
|
216
|
+
const fontSets = capabilities?.fontSets, hasFontSet = fontSets === true ? provider.hasFontSet : undefined;
|
|
217
|
+
if ((fontSets !== undefined && typeof fontSets !== 'boolean') ||
|
|
218
|
+
(fontSets === true && typeof hasFontSet !== 'function'))
|
|
219
|
+
throw new EgretError('PARAGRAPH_PROVIDER_INVALID');
|
|
220
|
+
const maxGeometryBytes = limit(options.maxGeometryBytes, 2097152, 0, 67108864);
|
|
221
|
+
const count = limit(options.maxEntries, 32, 1, 32), maxBytes = limit(options.maxImageBytes, 16777216, 4, 67108864), maxJobs = limit(options.maxPendingJobs, 32, 1, 32);
|
|
222
|
+
if (typeof identity !== 'string' || identity.length < 1 || identity.length > 8192 || typeof prepare !== 'function')
|
|
223
|
+
throw new EgretError('PARAGRAPH_PROVIDER_INVALID');
|
|
224
|
+
owner.assertOpen();
|
|
225
|
+
const type = createAssetType('egret.paragraph.v1.texture', isTexture);
|
|
226
|
+
const slots = Object.freeze(Array.from({ length: count }, (_, index) => ({
|
|
227
|
+
ref: createAssetRef(type, 'egret.paragraph.v1.slot.' + index),
|
|
228
|
+
key: undefined,
|
|
229
|
+
request: undefined,
|
|
230
|
+
result: undefined,
|
|
231
|
+
callers: 0,
|
|
232
|
+
resident: undefined,
|
|
233
|
+
residentPending: false,
|
|
234
|
+
used: 0
|
|
235
|
+
})));
|
|
236
|
+
const s = {
|
|
237
|
+
owner,
|
|
238
|
+
provider,
|
|
239
|
+
prepare,
|
|
240
|
+
hasFontSet,
|
|
241
|
+
supportsTextAlign,
|
|
242
|
+
supportsMaxLines,
|
|
243
|
+
supportsTextGeometry,
|
|
244
|
+
supportsStyledRuns,
|
|
245
|
+
maxGeometryBytes,
|
|
246
|
+
geometryBytes: 0,
|
|
247
|
+
slots,
|
|
248
|
+
maxBytes,
|
|
249
|
+
maxJobs,
|
|
250
|
+
textures: new Map(),
|
|
251
|
+
closed: false,
|
|
252
|
+
generation: 1,
|
|
253
|
+
clock: 0,
|
|
254
|
+
jobs: 0,
|
|
255
|
+
bytes: 0
|
|
256
|
+
};
|
|
257
|
+
const cache = Object.freeze({
|
|
258
|
+
profile: 'readonly-paragraph-v1',
|
|
259
|
+
acquire,
|
|
260
|
+
invalidate,
|
|
261
|
+
getStatus,
|
|
262
|
+
dispose
|
|
263
|
+
});
|
|
264
|
+
states.set(cache, s);
|
|
265
|
+
commitBinding([cache], owner.context);
|
|
266
|
+
commitParagraphCacheLifetime(assets, () => close(s));
|
|
267
|
+
try {
|
|
268
|
+
owner.register(type, {
|
|
269
|
+
async load(ref, context) {
|
|
270
|
+
live(s);
|
|
271
|
+
if (s.jobs >= s.maxJobs)
|
|
272
|
+
throw new EgretError('PARAGRAPH_CACHE_BUDGET');
|
|
273
|
+
const slot = slots.find(slot => slot.ref === ref), request = slot?.request;
|
|
274
|
+
if (!slot || !request)
|
|
275
|
+
throw new EgretError('PARAGRAPH_CACHE_INVALID');
|
|
276
|
+
const key = slot.key;
|
|
277
|
+
s.jobs++;
|
|
278
|
+
try {
|
|
279
|
+
const output = await Reflect.apply(prepare, provider, [request, Object.freeze({ signal: context.signal })]);
|
|
280
|
+
live(s);
|
|
281
|
+
if (context.signal.aborted || slot.key !== key)
|
|
282
|
+
throw new EgretError('PARAGRAPH_CANCELLED');
|
|
283
|
+
checkFontSet(s, request);
|
|
284
|
+
const prepared = snapshotParagraphRaster(output, request);
|
|
285
|
+
live(s);
|
|
286
|
+
if (context.signal.aborted || slot.key !== key)
|
|
287
|
+
throw new EgretError('PARAGRAPH_CANCELLED');
|
|
288
|
+
const image = prepared.image ??
|
|
289
|
+
createImageData2D({
|
|
290
|
+
width: 1,
|
|
291
|
+
height: 1,
|
|
292
|
+
pixels: new Uint8Array(4),
|
|
293
|
+
alphaMode: 'straight',
|
|
294
|
+
colorSpace: 'srgb'
|
|
295
|
+
});
|
|
296
|
+
const geometry = request.textGeometry
|
|
297
|
+
? snapshotParagraphTextGeometry(prepared.geometry, request, prepared.metrics)
|
|
298
|
+
: undefined;
|
|
299
|
+
const geometryBytes = geometry?.storageBytes ?? 0;
|
|
300
|
+
const bytes = image.width * image.height * 4;
|
|
301
|
+
evictFor(s, bytes, geometryBytes, slot);
|
|
302
|
+
live(s);
|
|
303
|
+
if (context.signal.aborted || slot.key !== key)
|
|
304
|
+
throw new EgretError('PARAGRAPH_CANCELLED');
|
|
305
|
+
const texture = createTexture(image), result = {
|
|
306
|
+
texture,
|
|
307
|
+
bytes,
|
|
308
|
+
geometryBytes,
|
|
309
|
+
prepared: Object.freeze({
|
|
310
|
+
metrics: prepared.metrics,
|
|
311
|
+
offsetX: prepared.offsetX,
|
|
312
|
+
offsetY: prepared.offsetY,
|
|
313
|
+
density: request.density,
|
|
314
|
+
...(geometry ? { geometry } : {})
|
|
315
|
+
})
|
|
316
|
+
};
|
|
317
|
+
s.textures.set(texture, result);
|
|
318
|
+
s.bytes += bytes;
|
|
319
|
+
s.geometryBytes += geometryBytes;
|
|
320
|
+
slot.result = result;
|
|
321
|
+
return texture;
|
|
322
|
+
}
|
|
323
|
+
finally {
|
|
324
|
+
s.jobs--;
|
|
325
|
+
}
|
|
326
|
+
},
|
|
327
|
+
dispose(texture) {
|
|
328
|
+
const result = s.textures.get(texture);
|
|
329
|
+
if (result) {
|
|
330
|
+
s.textures.delete(texture);
|
|
331
|
+
s.bytes -= result.bytes;
|
|
332
|
+
s.geometryBytes -= result.geometryBytes;
|
|
333
|
+
}
|
|
334
|
+
texture.dispose();
|
|
335
|
+
}
|
|
336
|
+
});
|
|
337
|
+
owner.context.registerTextFieldCache?.(cache, scope => createParagraphNode(scope, {
|
|
338
|
+
context: owner.context,
|
|
339
|
+
assertOpen: () => live(s),
|
|
340
|
+
generation: () => s.generation,
|
|
341
|
+
acquire: (request, signal) => acquire.call(cache, request, { signal })
|
|
342
|
+
}), 'paragraph');
|
|
343
|
+
}
|
|
344
|
+
catch (cause) {
|
|
345
|
+
close(s);
|
|
346
|
+
throw cause;
|
|
347
|
+
}
|
|
348
|
+
return cache;
|
|
349
|
+
}
|
|
350
|
+
finally {
|
|
351
|
+
finish();
|
|
352
|
+
}
|
|
353
|
+
}
|
|
354
|
+
//# sourceMappingURL=ParagraphCache.js.map
|
|
@@ -0,0 +1,4 @@
|
|
|
1
|
+
import type { ParagraphMetrics, ParagraphRequest, ParagraphTextGeometry, ParagraphTextGeometryData } from './types.js';
|
|
2
|
+
/** Copy native/source geometry once; subsequent queries retain no provider/native object. */
|
|
3
|
+
export declare function snapshotParagraphTextGeometry(data: ParagraphTextGeometryData, request: ParagraphRequest, metrics: ParagraphMetrics): ParagraphTextGeometry;
|
|
4
|
+
//# sourceMappingURL=geometry.d.ts.map
|
|
@@ -0,0 +1,180 @@
|
|
|
1
|
+
// SPDX-License-Identifier: Apache-2.0
|
|
2
|
+
import { EgretError } from '../EgretError.js';
|
|
3
|
+
const invalid = () => {
|
|
4
|
+
throw new EgretError('PARAGRAPH_PROVIDER_RESULT_INVALID');
|
|
5
|
+
};
|
|
6
|
+
const scalar = (v) => typeof v === 'number' && Number.isFinite(v) && Math.abs(v) <= 1048576 ? (v === 0 ? 0 : v) : invalid();
|
|
7
|
+
function boundary(text, value) {
|
|
8
|
+
if (!Number.isSafeInteger(value) || value < 0 || value > text.length)
|
|
9
|
+
return invalid();
|
|
10
|
+
const unit = text.charCodeAt(value), prior = text.charCodeAt(value - 1);
|
|
11
|
+
if ((unit >= 0xdc00 && unit <= 0xdfff && prior >= 0xd800 && prior <= 0xdbff) || (prior === 13 && unit === 10))
|
|
12
|
+
return invalid();
|
|
13
|
+
return value;
|
|
14
|
+
}
|
|
15
|
+
function box(value) {
|
|
16
|
+
const left = scalar(value.left), top = scalar(value.top), right = scalar(value.right), bottom = scalar(value.bottom);
|
|
17
|
+
if (right < left || bottom < top)
|
|
18
|
+
return invalid();
|
|
19
|
+
return { left, top, right, bottom };
|
|
20
|
+
}
|
|
21
|
+
/** Copy native/source geometry once; subsequent queries retain no provider/native object. */
|
|
22
|
+
export function snapshotParagraphTextGeometry(data, request, metrics) {
|
|
23
|
+
if (!data || typeof data !== 'object')
|
|
24
|
+
return invalid();
|
|
25
|
+
const sourceLines = data.lines, sourceClusters = data.clusters;
|
|
26
|
+
if (!Array.isArray(sourceLines) || !Array.isArray(sourceClusters))
|
|
27
|
+
return invalid();
|
|
28
|
+
const lineCount = sourceLines.length, clusterCount = sourceClusters.length;
|
|
29
|
+
if (lineCount !== metrics.lines.length || !Number.isSafeInteger(clusterCount) || clusterCount > 8192)
|
|
30
|
+
return invalid();
|
|
31
|
+
const text = request.text, lines = [], clusters = [];
|
|
32
|
+
for (let i = 0; i < lineCount; i++) {
|
|
33
|
+
const row = sourceLines[i], metric = metrics.lines[i];
|
|
34
|
+
const start = boundary(text, row.start), end = boundary(text, row.end);
|
|
35
|
+
if (start !== metric.start ||
|
|
36
|
+
end < start ||
|
|
37
|
+
end > metric.end ||
|
|
38
|
+
(end !== metric.end && !(metrics.truncated && i === lineCount - 1)))
|
|
39
|
+
return invalid();
|
|
40
|
+
lines.push(Object.freeze({ start, end, ...box(row) }));
|
|
41
|
+
}
|
|
42
|
+
let previousEnd = 0;
|
|
43
|
+
for (let index = 0; index < clusterCount; index++) {
|
|
44
|
+
const cluster = sourceClusters[index];
|
|
45
|
+
const start = boundary(text, cluster.start), end = boundary(text, cluster.end), lineIndex = cluster.lineIndex, direction = cluster.direction;
|
|
46
|
+
if (start < previousEnd ||
|
|
47
|
+
end <= start ||
|
|
48
|
+
!Number.isSafeInteger(lineIndex) ||
|
|
49
|
+
lineIndex < 0 ||
|
|
50
|
+
lineIndex >= lines.length ||
|
|
51
|
+
(direction !== 'ltr' && direction !== 'rtl'))
|
|
52
|
+
return invalid();
|
|
53
|
+
const line = lines[lineIndex];
|
|
54
|
+
if (start < line.start || end > line.end || /[\r\n]/.test(text.slice(start, end)))
|
|
55
|
+
return invalid();
|
|
56
|
+
previousEnd = end;
|
|
57
|
+
clusters.push(Object.freeze({ start, end, lineIndex, direction, ...box(cluster) }));
|
|
58
|
+
}
|
|
59
|
+
Object.freeze(lines);
|
|
60
|
+
Object.freeze(clusters);
|
|
61
|
+
// This bounded logical fee includes source units and fixed scalar rows. It is
|
|
62
|
+
// explicitly not a measurement of VM objects, physical memory or Wasm heaps.
|
|
63
|
+
const storageBytes = text.length * 2 + lines.length * 112 + clusters.length * 160;
|
|
64
|
+
const stops = lines.map(() => []);
|
|
65
|
+
const leading = (c) => (c.direction === 'rtl' ? c.right : c.left);
|
|
66
|
+
const trailing = (c) => (c.direction === 'rtl' ? c.left : c.right);
|
|
67
|
+
const stop = (offset, affinity, lineIndex, x) => Object.freeze({ offset, affinity, lineIndex, x, top: lines[lineIndex].top, bottom: lines[lineIndex].bottom });
|
|
68
|
+
for (const cluster of clusters) {
|
|
69
|
+
stops[cluster.lineIndex].push(stop(cluster.start, 'downstream', cluster.lineIndex, leading(cluster)), stop(cluster.end, 'upstream', cluster.lineIndex, trailing(cluster)));
|
|
70
|
+
}
|
|
71
|
+
for (let i = 0; i < lines.length; i++) {
|
|
72
|
+
const line = lines[i], row = stops[i];
|
|
73
|
+
if (!row.length) {
|
|
74
|
+
const x = request.direction === 'rtl' ? line.right : line.left;
|
|
75
|
+
row.push(stop(line.start, 'downstream', i, x));
|
|
76
|
+
if (line.end !== line.start)
|
|
77
|
+
row.push(stop(line.end, 'upstream', i, x));
|
|
78
|
+
}
|
|
79
|
+
else {
|
|
80
|
+
// Native line ranges may include trailing formatting with no glyph box.
|
|
81
|
+
if (!row.some(s => s.offset === line.start))
|
|
82
|
+
row.push(stop(line.start, 'downstream', i, row[0].x));
|
|
83
|
+
if (!row.some(s => s.offset === line.end))
|
|
84
|
+
row.push(stop(line.end, 'upstream', i, row[row.length - 1].x));
|
|
85
|
+
}
|
|
86
|
+
Object.freeze(row);
|
|
87
|
+
}
|
|
88
|
+
Object.freeze(stops);
|
|
89
|
+
const all = Object.freeze(stops.flat());
|
|
90
|
+
function queryOffset(offset) {
|
|
91
|
+
if (!Number.isSafeInteger(offset) || offset < 0 || offset > text.length)
|
|
92
|
+
throw new EgretError('PARAGRAPH_GEOMETRY_POSITION_INVALID');
|
|
93
|
+
}
|
|
94
|
+
function caret(offset, affinity = 'downstream') {
|
|
95
|
+
queryOffset(offset);
|
|
96
|
+
if (affinity !== 'upstream' && affinity !== 'downstream')
|
|
97
|
+
throw new EgretError('PARAGRAPH_GEOMETRY_POSITION_INVALID');
|
|
98
|
+
if (!all.length)
|
|
99
|
+
return undefined;
|
|
100
|
+
const containing = clusters.find(c => c.start < offset && offset < c.end);
|
|
101
|
+
if (containing)
|
|
102
|
+
offset = affinity === 'upstream' ? containing.start : containing.end;
|
|
103
|
+
const matching = all.filter(s => s.offset === offset), exact = matching.filter(s => s.affinity === affinity);
|
|
104
|
+
if (exact.length)
|
|
105
|
+
return affinity === 'upstream' ? exact[0] : exact[exact.length - 1];
|
|
106
|
+
if (matching.length)
|
|
107
|
+
return affinity === 'upstream' ? matching[0] : matching[matching.length - 1];
|
|
108
|
+
// Hard-break interiors and hidden truncated source map to admitted stops;
|
|
109
|
+
// they never manufacture a caret inside CRLF or a synthetic ellipsis.
|
|
110
|
+
const directional = all.filter(s => (affinity === 'upstream' ? s.offset < offset : s.offset > offset));
|
|
111
|
+
const candidates = directional.length ? directional : all;
|
|
112
|
+
return candidates.reduce((best, s) => (Math.abs(s.offset - offset) < Math.abs(best.offset - offset) ? s : best));
|
|
113
|
+
}
|
|
114
|
+
const geometry = Object.freeze({
|
|
115
|
+
text,
|
|
116
|
+
storageBytes,
|
|
117
|
+
lines,
|
|
118
|
+
clusters,
|
|
119
|
+
getCaret: caret,
|
|
120
|
+
hitTest(x, y) {
|
|
121
|
+
if (typeof x !== 'number' || !Number.isFinite(x) || typeof y !== 'number' || !Number.isFinite(y))
|
|
122
|
+
throw new EgretError('PARAGRAPH_GEOMETRY_POINT_INVALID');
|
|
123
|
+
if (!lines.length)
|
|
124
|
+
return undefined;
|
|
125
|
+
const distance = (top, bottom) => (y < top ? top - y : y > bottom ? y - bottom : 0);
|
|
126
|
+
let lineIndex = 0;
|
|
127
|
+
for (let i = 1; i < lines.length; i++)
|
|
128
|
+
if (distance(lines[i].top, lines[i].bottom) < distance(lines[lineIndex].top, lines[lineIndex].bottom))
|
|
129
|
+
lineIndex = i;
|
|
130
|
+
const row = stops[lineIndex];
|
|
131
|
+
const cluster = clusters.find(c => c.lineIndex === lineIndex && c.right > c.left && x >= c.left && x <= c.right);
|
|
132
|
+
let selected;
|
|
133
|
+
if (cluster) {
|
|
134
|
+
const before = x < (cluster.left + cluster.right) / 2;
|
|
135
|
+
const start = cluster.direction === 'ltr' ? before : !before;
|
|
136
|
+
const offset = start ? cluster.start : cluster.end, affinity = start ? 'downstream' : 'upstream';
|
|
137
|
+
selected = row.find(s => s.offset === offset && s.affinity === affinity);
|
|
138
|
+
}
|
|
139
|
+
else
|
|
140
|
+
selected = row.reduce((best, s) => (Math.abs(s.x - x) < Math.abs(best.x - x) ? s : best));
|
|
141
|
+
const line = lines[lineIndex];
|
|
142
|
+
return Object.freeze({ ...selected, inside: cluster !== undefined && y >= line.top && y <= line.bottom });
|
|
143
|
+
},
|
|
144
|
+
getSelectionRects(start, end) {
|
|
145
|
+
queryOffset(start);
|
|
146
|
+
queryOffset(end);
|
|
147
|
+
if (end < start)
|
|
148
|
+
throw new EgretError('PARAGRAPH_GEOMETRY_POSITION_INVALID');
|
|
149
|
+
if (start === end)
|
|
150
|
+
return Object.freeze([]);
|
|
151
|
+
const rows = clusters
|
|
152
|
+
.filter(c => c.start < end && c.end > start && c.right > c.left && c.bottom > c.top)
|
|
153
|
+
.map(c => ({ ...c }))
|
|
154
|
+
.sort((a, b) => a.lineIndex - b.lineIndex || a.left - b.left);
|
|
155
|
+
const merged = [];
|
|
156
|
+
for (const row of rows) {
|
|
157
|
+
const last = merged[merged.length - 1];
|
|
158
|
+
if (last &&
|
|
159
|
+
last.lineIndex === row.lineIndex &&
|
|
160
|
+
last.direction === row.direction &&
|
|
161
|
+
last.top === row.top &&
|
|
162
|
+
last.bottom === row.bottom &&
|
|
163
|
+
Math.abs(last.right - row.left) <= 0.0001 &&
|
|
164
|
+
(last.direction === 'ltr' ? last.end === row.start : last.start === row.end)) {
|
|
165
|
+
merged[merged.length - 1] = {
|
|
166
|
+
...last,
|
|
167
|
+
start: Math.min(last.start, row.start),
|
|
168
|
+
end: Math.max(last.end, row.end),
|
|
169
|
+
right: row.right
|
|
170
|
+
};
|
|
171
|
+
}
|
|
172
|
+
else
|
|
173
|
+
merged.push(row);
|
|
174
|
+
}
|
|
175
|
+
return Object.freeze(merged.map(row => Object.freeze(row)));
|
|
176
|
+
}
|
|
177
|
+
});
|
|
178
|
+
return geometry;
|
|
179
|
+
}
|
|
180
|
+
//# sourceMappingURL=geometry.js.map
|
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
import type { ParagraphRequestInput, ParagraphRequest, ParagraphRaster } from './types.js';
|
|
2
|
+
/** Snapshot caller values before queueing: later request/style mutations have no authority. */
|
|
3
|
+
export declare function snapshotParagraphRequest(input: ParagraphRequestInput): ParagraphRequest;
|
|
4
|
+
/** Own public metrics; provider memory or mutable arrays never become committed UI state. */
|
|
5
|
+
export declare function snapshotParagraphRaster(value: ParagraphRaster, request: ParagraphRequest): ParagraphRaster;
|
|
6
|
+
//# sourceMappingURL=request.d.ts.map
|