@farm.js/react 0.1.0-beta.3 → 0.1.0-beta.30
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/README.md +884 -51
- package/dist/compiler-runtime.cjs +8116 -831
- package/dist/compiler-runtime.cjs.map +1 -1
- package/dist/compiler-runtime.d.mts +281 -4
- package/dist/compiler-runtime.d.ts +281 -4
- package/dist/compiler-runtime.mjs +7999 -832
- package/dist/compiler-runtime.mjs.map +1 -1
- package/dist/index.cjs +45 -5
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.mts +15 -3
- package/dist/index.d.ts +15 -3
- package/dist/index.mjs +45 -5
- package/dist/index.mjs.map +1 -1
- package/dist/list.cjs +24 -1
- package/dist/list.cjs.map +1 -1
- package/dist/list.mjs +24 -1
- package/dist/list.mjs.map +1 -1
- package/dist/vite.cjs +5577 -314
- package/dist/vite.cjs.map +1 -1
- package/dist/vite.d.mts +2 -0
- package/dist/vite.d.ts +2 -0
- package/dist/vite.mjs +5579 -316
- package/dist/vite.mjs.map +1 -1
- package/package.json +13 -9
|
@@ -1,12 +1,77 @@
|
|
|
1
1
|
import React from 'react';
|
|
2
2
|
|
|
3
3
|
type CompilerStateUpdater = unknown | ((previous: unknown) => unknown);
|
|
4
|
+
type CompilerRuntimeReactivity = "static" | "hybrid";
|
|
5
|
+
type CompilerKeyedCollectionKind = "set" | "map";
|
|
6
|
+
type CompilerKeyedCollectionMutation = "set-add" | "set-delete" | "map-set" | "map-delete";
|
|
7
|
+
/**
|
|
8
|
+
* @internal Executes a compiler-proven Array.map pipeline and records its final same-order delta.
|
|
9
|
+
* The three-argument value/index form remains accepted for older generated output.
|
|
10
|
+
*/
|
|
11
|
+
declare function createCompilerKeyedMapUpdate(previous: unknown, valueOrPipeline: unknown, changedIndices?: unknown): unknown;
|
|
12
|
+
/**
|
|
13
|
+
* @internal Executes proven native maps within a keyed reorder pipeline.
|
|
14
|
+
* The three-argument form remains accepted for older generated output.
|
|
15
|
+
*/
|
|
16
|
+
declare function createCompilerKeyedArrayMapPipeline(previous: unknown, methodOrPipeline: unknown, callback?: unknown): unknown;
|
|
17
|
+
/** @internal Executes a queued native map next to a compiler-proven keyed-array reorder. */
|
|
18
|
+
declare function createCompilerKeyedArrayQueuedMapPipeline(previous: unknown, pipeline: (...values: readonly unknown[]) => unknown): unknown;
|
|
19
|
+
/** @internal Executes a safe map inside one compiler-proven rolling-window setter chain. */
|
|
20
|
+
declare function createCompilerKeyedArrayRollingWindowMapPipeline(previous: unknown, pipeline: (...values: readonly unknown[]) => unknown): unknown;
|
|
21
|
+
/** @internal Executes a native reorder after a proven same-key map pipeline. */
|
|
22
|
+
declare function createCompilerKeyedArrayMapReorder(previous: unknown, method: unknown, ...args: readonly unknown[]): unknown;
|
|
23
|
+
/** @internal Records a compiler-proven immutable keyed-array append and returns the Array. */
|
|
24
|
+
declare function createCompilerKeyedArrayAppend(previous: unknown, value: unknown): unknown;
|
|
25
|
+
/** @internal Records an append that may follow a compiler-proven structural update. */
|
|
26
|
+
declare function createCompilerKeyedArrayStructuralAppend(previous: unknown, value: unknown): unknown;
|
|
27
|
+
/** @internal Records an append that directly follows compiler-proven mapped structural work. */
|
|
28
|
+
declare function createCompilerKeyedArrayMappedStructuralAppend(previous: unknown, value: unknown): unknown;
|
|
29
|
+
/** @internal Executes safe maps while retaining structural append lineage. */
|
|
30
|
+
declare function createCompilerKeyedArrayStructuralAppendMapPipeline(previous: unknown, pipeline: (...values: readonly unknown[]) => unknown): unknown;
|
|
31
|
+
/** @internal Records a compiler-proven immutable keyed-array prepend and returns the Array. */
|
|
32
|
+
declare function createCompilerKeyedArrayPrepend(previous: unknown, value: unknown): unknown;
|
|
33
|
+
/** @internal Records a prepend that may follow a compiler-proven structural update. */
|
|
34
|
+
declare function createCompilerKeyedArrayStructuralPrepend(previous: unknown, value: unknown): unknown;
|
|
35
|
+
/** @internal Records a prepend that directly follows compiler-proven mapped structural work. */
|
|
36
|
+
declare function createCompilerKeyedArrayMappedStructuralPrepend(previous: unknown, value: unknown): unknown;
|
|
37
|
+
/** @internal Executes safe maps while retaining structural prepend lineage. */
|
|
38
|
+
declare function createCompilerKeyedArrayStructuralPrependMapPipeline(previous: unknown, pipeline: (...values: readonly unknown[]) => unknown): unknown;
|
|
39
|
+
/** @internal Executes Array.filter while recording compiler-proven removal positions. */
|
|
40
|
+
declare function createCompilerKeyedArrayFilter(previous: unknown, method: unknown, predicate: unknown): unknown;
|
|
41
|
+
/** @internal Executes a compiler-proven native Array.slice and records its retained interval. */
|
|
42
|
+
declare function createCompilerKeyedArraySlice(previous: unknown, method: unknown, ...args: readonly number[]): unknown;
|
|
43
|
+
/** @internal Retains mapped lineage through a compiler-proven terminal filter or slice. */
|
|
44
|
+
declare function finalizeCompilerKeyedArrayMappedStructuralUpdate(value: unknown): unknown;
|
|
45
|
+
/** @internal Records a compiler-proven retained tail followed by incoming keyed rows. */
|
|
46
|
+
declare function createCompilerKeyedArrayRollingWindow(previous: unknown, retained: unknown, value: unknown): unknown;
|
|
47
|
+
/** @internal Records one rolling step inside a compiler-proven mapped window chain. */
|
|
48
|
+
declare function createCompilerKeyedArrayMappedRollingWindow(previous: unknown, retained: unknown, value: unknown): unknown;
|
|
49
|
+
/** @internal Executes a native known-position insert, removal, or replacement and records it. */
|
|
50
|
+
declare function createCompilerKeyedArrayPositionUpdate(previous: unknown, method: unknown, kind: "insert" | "remove" | "replace", position: number, ...args: readonly unknown[]): unknown;
|
|
51
|
+
/** @internal Executes a native exact-position batch insertion and records it. */
|
|
52
|
+
declare function createCompilerKeyedArrayBatchInsert(previous: unknown, method: unknown, position: number, ...items: readonly unknown[]): unknown;
|
|
53
|
+
/** @internal Executes a native exact-window replacement and records it. */
|
|
54
|
+
declare function createCompilerKeyedArrayWindowReplace(previous: unknown, method: unknown, position: number, deleteCount: number, ...items: readonly unknown[]): unknown;
|
|
55
|
+
/** @internal Executes a native reverse and records its exact keyed-row permutation. */
|
|
56
|
+
declare function createCompilerKeyedArrayReorder(previous: unknown, method: unknown): unknown;
|
|
57
|
+
/** @internal Executes a native immutable sort and records its keyed-row permutation. */
|
|
58
|
+
declare function createCompilerKeyedArraySort(previous: unknown, method: unknown, ...args: readonly unknown[]): unknown;
|
|
59
|
+
/** @internal Executes a native reverse after a compiler-proven filter or slice pipeline. */
|
|
60
|
+
declare function createCompilerKeyedArrayStructuralReorder(previous: unknown, method: unknown): unknown;
|
|
61
|
+
/** @internal Executes a native sort after a compiler-proven filter or slice pipeline. */
|
|
62
|
+
declare function createCompilerKeyedArrayStructuralSort(previous: unknown, method: unknown, ...args: readonly unknown[]): unknown;
|
|
63
|
+
/** @internal Preserves a proven native collection mutation while recording its executed key. */
|
|
64
|
+
declare function applyCompilerKeyedCollectionMutation(collection: unknown, method: unknown, operation: CompilerKeyedCollectionMutation, key: unknown, value?: unknown): unknown;
|
|
65
|
+
/** @internal Connects compiler-owned immutable Set/Map mutations to their committed source. */
|
|
66
|
+
declare function createCompilerKeyedCollectionUpdate(previous: unknown, value: unknown, kind: CompilerKeyedCollectionKind): unknown;
|
|
4
67
|
interface CompilerCell {
|
|
5
68
|
get(): unknown;
|
|
6
69
|
set(next: CompilerStateUpdater): void;
|
|
7
70
|
}
|
|
8
71
|
interface CompilerTextBinding<Props> {
|
|
9
72
|
kind: "text";
|
|
73
|
+
/** Runtime tracking is useful only for compiler-proven short-circuiting readers. */
|
|
74
|
+
tracking?: "dynamic";
|
|
10
75
|
path: readonly number[];
|
|
11
76
|
/** Stable ref target emitted by newer compiler versions. */
|
|
12
77
|
target?: number;
|
|
@@ -15,6 +80,8 @@ interface CompilerTextBinding<Props> {
|
|
|
15
80
|
}
|
|
16
81
|
interface CompilerAttributeBinding<Props> {
|
|
17
82
|
kind: "attribute";
|
|
83
|
+
/** Runtime tracking is useful only for compiler-proven short-circuiting readers. */
|
|
84
|
+
tracking?: "dynamic";
|
|
18
85
|
path: readonly number[];
|
|
19
86
|
/** Stable ref target emitted by newer compiler versions. */
|
|
20
87
|
target?: number;
|
|
@@ -24,6 +91,8 @@ interface CompilerAttributeBinding<Props> {
|
|
|
24
91
|
}
|
|
25
92
|
interface CompilerStyleBinding<Props> {
|
|
26
93
|
kind: "style";
|
|
94
|
+
/** Runtime tracking is useful only for compiler-proven short-circuiting readers. */
|
|
95
|
+
tracking?: "dynamic";
|
|
27
96
|
path: readonly number[];
|
|
28
97
|
/** Stable ref target emitted by newer compiler versions. */
|
|
29
98
|
target?: number;
|
|
@@ -58,10 +127,14 @@ interface CompilerHostElement {
|
|
|
58
127
|
value: unknown;
|
|
59
128
|
}[];
|
|
60
129
|
children: readonly (CompilerHostElement | unknown)[];
|
|
130
|
+
/** Direct-child structure owned without creating another React fiber. */
|
|
131
|
+
block?: CompilerHostBlock;
|
|
61
132
|
}
|
|
62
133
|
type CompilerKeyedRowElement = CompilerHostElement;
|
|
63
134
|
interface CompilerKeyedRowEvent {
|
|
64
135
|
name: string;
|
|
136
|
+
/** Host-element path relative to the keyed row root. */
|
|
137
|
+
path?: readonly number[];
|
|
65
138
|
invoke(item: unknown, index: number, event: React.SyntheticEvent): unknown;
|
|
66
139
|
}
|
|
67
140
|
interface CompilerKeyedRowConditionalBranch {
|
|
@@ -82,10 +155,45 @@ interface CompilerHostConditionalBinding {
|
|
|
82
155
|
name?: string;
|
|
83
156
|
read(): unknown;
|
|
84
157
|
}
|
|
158
|
+
interface CompilerStaticRangeBinding {
|
|
159
|
+
kind: "text" | "attribute" | "style";
|
|
160
|
+
/** Static segment before range N, or the trailing segment at ranges.length. */
|
|
161
|
+
segment: number;
|
|
162
|
+
/** Direct host sibling inside that static segment. */
|
|
163
|
+
sibling: number;
|
|
164
|
+
/** Host-element path relative to the selected static sibling. */
|
|
165
|
+
path: readonly number[];
|
|
166
|
+
name?: string;
|
|
167
|
+
read(): unknown;
|
|
168
|
+
}
|
|
85
169
|
interface CompilerHostConditionalBranch {
|
|
86
170
|
create(): CompilerHostElement;
|
|
87
171
|
bindings: readonly CompilerHostConditionalBinding[];
|
|
88
172
|
}
|
|
173
|
+
interface CompilerHostConditionalRanges {
|
|
174
|
+
kind: "conditional-ranges";
|
|
175
|
+
id: number;
|
|
176
|
+
ranges: readonly CompilerConditionalRange[];
|
|
177
|
+
trailing: number;
|
|
178
|
+
bindings?: readonly CompilerStaticRangeBinding[];
|
|
179
|
+
}
|
|
180
|
+
interface CompilerHostKeyedRanges {
|
|
181
|
+
kind: "keyed-ranges";
|
|
182
|
+
id: number;
|
|
183
|
+
ranges: readonly CompilerKeyedRange[];
|
|
184
|
+
trailing: number;
|
|
185
|
+
bindings?: readonly CompilerStaticRangeBinding[];
|
|
186
|
+
/** Compiler output may store only static direct children and materialize rows from the ranges. */
|
|
187
|
+
staticChildrenOnly?: boolean;
|
|
188
|
+
}
|
|
189
|
+
interface CompilerHostMixedRanges {
|
|
190
|
+
kind: "mixed-ranges";
|
|
191
|
+
id: number;
|
|
192
|
+
ranges: readonly CompilerMixedRange[];
|
|
193
|
+
trailing: number;
|
|
194
|
+
bindings?: readonly CompilerStaticRangeBinding[];
|
|
195
|
+
}
|
|
196
|
+
type CompilerHostBlock = CompilerHostConditionalRanges | CompilerHostKeyedRanges | CompilerHostMixedRanges;
|
|
89
197
|
interface CompilerHostConditionalBlockProps {
|
|
90
198
|
id: number;
|
|
91
199
|
render(): React.ReactElement;
|
|
@@ -111,22 +219,63 @@ interface CompilerConditionalRangesBlockProps {
|
|
|
111
219
|
ranges: readonly CompilerConditionalRange[];
|
|
112
220
|
/** Number of static direct host siblings after the final conditional slot. */
|
|
113
221
|
trailing: number;
|
|
222
|
+
bindings?: readonly CompilerStaticRangeBinding[];
|
|
114
223
|
}
|
|
115
224
|
interface CompilerKeyedRowBinding {
|
|
116
225
|
kind: "text" | "attribute" | "style";
|
|
117
226
|
path: readonly number[];
|
|
118
227
|
name?: string;
|
|
228
|
+
/** Component state cells read by this binding, when emitted by the compiler. */
|
|
229
|
+
dependencies?: readonly number[];
|
|
230
|
+
/** A compiler-proven primitive value compared strictly with this row's key. */
|
|
231
|
+
identityTarget?: {
|
|
232
|
+
dependency: number;
|
|
233
|
+
read(): unknown;
|
|
234
|
+
};
|
|
235
|
+
/** A compiler-proven native Set whose members are compared with this row's key. */
|
|
236
|
+
membershipTarget?: {
|
|
237
|
+
dependency: number;
|
|
238
|
+
read(): unknown;
|
|
239
|
+
};
|
|
240
|
+
/** A compiler-proven native Map whose values are read with this row's key. */
|
|
241
|
+
mapLookupTarget?: {
|
|
242
|
+
dependency: number;
|
|
243
|
+
read(): unknown;
|
|
244
|
+
};
|
|
119
245
|
read(item: unknown, index: number): unknown;
|
|
120
246
|
}
|
|
121
247
|
interface CompilerKeyedRowsBlockProps {
|
|
122
248
|
id: number;
|
|
123
249
|
render(event: (item: unknown, index: number, eventId: number) => React.EventHandler<React.SyntheticEvent>, conditional: (item: unknown, index: number, conditionalId: number, render: (item: unknown, index: number) => React.ReactNode) => React.ReactNode): React.ReactElement;
|
|
124
250
|
items(): Iterable<unknown> | null | undefined;
|
|
251
|
+
/** Complete component-state dependencies used anywhere inside this boundary. */
|
|
252
|
+
dependencies?: readonly number[];
|
|
253
|
+
/** State cells that can change the row collection or its key projection. */
|
|
254
|
+
structureDependencies?: readonly number[];
|
|
255
|
+
/** Direct state cell supplying items, eligible for compiler-emitted update hints. */
|
|
256
|
+
collectionDependency?: number;
|
|
257
|
+
/** Compiler proof that shifted row indexes are not observed by this boundary. */
|
|
258
|
+
filterIndexIndependent?: boolean;
|
|
259
|
+
/** Compiler proof that prepending cannot expose shifted indexes to existing rows. */
|
|
260
|
+
prependIndexIndependent?: boolean;
|
|
261
|
+
/** Compiler proof that a known-position insert cannot expose shifted row indexes. */
|
|
262
|
+
positionIndexIndependent?: boolean;
|
|
263
|
+
/** Compiler proof that reordering cannot expose changed row indexes. */
|
|
264
|
+
reorderIndexIndependent?: boolean;
|
|
125
265
|
rowKey(item: unknown, index: number): React.Key;
|
|
126
266
|
create(item: unknown, index: number): CompilerKeyedRowElement;
|
|
127
267
|
bindings: readonly CompilerKeyedRowBinding[];
|
|
128
268
|
events?: readonly CompilerKeyedRowEvent[];
|
|
269
|
+
/** Route compiler-proven bubbling row events through the stable React container. */
|
|
270
|
+
delegateEvents?: boolean;
|
|
129
271
|
conditionals?: readonly CompilerKeyedRowConditional[];
|
|
272
|
+
/** Row descriptors contain compiler-owned nested host scopes. */
|
|
273
|
+
hostBlocks?: boolean;
|
|
274
|
+
/**
|
|
275
|
+
* Compiler proof that every value differing between rows is a binding, so a
|
|
276
|
+
* row can be cloned from one already built with its bindings reapplied.
|
|
277
|
+
*/
|
|
278
|
+
cloneRows?: boolean;
|
|
130
279
|
}
|
|
131
280
|
interface CompilerKeyedRange {
|
|
132
281
|
/** Number of static direct host siblings between this range and the previous range. */
|
|
@@ -136,6 +285,17 @@ interface CompilerKeyedRange {
|
|
|
136
285
|
create(item: unknown, index: number): CompilerKeyedRowElement;
|
|
137
286
|
bindings: readonly CompilerKeyedRowBinding[];
|
|
138
287
|
}
|
|
288
|
+
type CompilerMixedRange = ({
|
|
289
|
+
kind: "conditional";
|
|
290
|
+
} & CompilerConditionalRange) | ({
|
|
291
|
+
kind: "keyed";
|
|
292
|
+
} & CompilerKeyedRange);
|
|
293
|
+
interface CompilerMixedRangesBlockProps {
|
|
294
|
+
id: number;
|
|
295
|
+
render(): React.ReactElement;
|
|
296
|
+
create(): CompilerHostElement;
|
|
297
|
+
rootRef?: React.RefCallback<Element>;
|
|
298
|
+
}
|
|
139
299
|
interface CompilerKeyedRangesBlockProps {
|
|
140
300
|
id: number;
|
|
141
301
|
render(): React.ReactElement;
|
|
@@ -143,6 +303,7 @@ interface CompilerKeyedRangesBlockProps {
|
|
|
143
303
|
ranges: readonly CompilerKeyedRange[];
|
|
144
304
|
/** Number of static direct host siblings after the final keyed range. */
|
|
145
305
|
trailing: number;
|
|
306
|
+
bindings?: readonly CompilerStaticRangeBinding[];
|
|
146
307
|
}
|
|
147
308
|
interface CompilerComponentBlockProps {
|
|
148
309
|
id: number;
|
|
@@ -155,27 +316,143 @@ interface CompilerBlockRuntime {
|
|
|
155
316
|
KeyedList: React.ComponentType<CompilerKeyedListBlockProps>;
|
|
156
317
|
KeyedRows: React.ComponentType<CompilerKeyedRowsBlockProps>;
|
|
157
318
|
KeyedRanges: React.ComponentType<CompilerKeyedRangesBlockProps>;
|
|
319
|
+
MixedRanges: React.ComponentType<CompilerMixedRangesBlockProps>;
|
|
158
320
|
Component: React.ComponentType<CompilerComponentBlockProps>;
|
|
159
321
|
target(id: number): React.RefCallback<Element>;
|
|
160
322
|
}
|
|
161
323
|
type CompilerBinding<Props> = CompilerTextBinding<Props> | CompilerAttributeBinding<Props> | CompilerStyleBinding<Props> | CompilerConditionalBlockBinding;
|
|
162
324
|
interface CompiledComponentDefinition<Props> {
|
|
163
325
|
displayName: string;
|
|
326
|
+
/** Scheduler selected by the compiler. Hand-authored definitions default to `static`. */
|
|
327
|
+
reactivity?: CompilerRuntimeReactivity;
|
|
164
328
|
/** Stable development-only identity used to preserve state across compatible refreshes. */
|
|
165
329
|
hmrId?: string;
|
|
166
330
|
/** Changes when the compiler-owned state layout is no longer refresh-compatible. */
|
|
167
331
|
stateSignature?: string;
|
|
168
332
|
initialize(props: Props): readonly unknown[];
|
|
333
|
+
/**
|
|
334
|
+
* Compiler-emitted flat prop reads. Primitive values can share the local
|
|
335
|
+
* dependency graph; identity-bearing values retain normal React rendering.
|
|
336
|
+
*/
|
|
337
|
+
readProps?(props: Props): readonly unknown[];
|
|
169
338
|
render(props: Props, state: readonly CompilerCell[], blocks: CompilerBlockRuntime): React.ReactElement;
|
|
170
339
|
bindings: readonly CompilerBinding<Props>[];
|
|
171
340
|
}
|
|
341
|
+
type CompilerBlockRefresh = (afterCommit?: () => void, dirtyState?: ReadonlySet<number>) => void;
|
|
342
|
+
interface CompilerRuntimeFeatureOwner {
|
|
343
|
+
setRoot(id: number, root: Element | null, expectedRoot?: Element | null): void;
|
|
344
|
+
subscribe(id: number, refresh: CompilerBlockRefresh): () => void;
|
|
345
|
+
/** Opaque identity used to detect compatible definition replacement. */
|
|
346
|
+
getDefinitionVersion?(): unknown;
|
|
347
|
+
}
|
|
348
|
+
interface CompilerRuntimeFeature {
|
|
349
|
+
/** Stable identity used by Fast Refresh compatibility checks. */
|
|
350
|
+
name: string;
|
|
351
|
+
create(owner: CompilerRuntimeFeatureOwner): Partial<CompilerBlockRuntime>;
|
|
352
|
+
}
|
|
353
|
+
declare const conditionalRuntimeFeature: CompilerRuntimeFeature;
|
|
354
|
+
declare const hostConditionalRuntimeFeature: CompilerRuntimeFeature;
|
|
355
|
+
declare const conditionalRangesRuntimeFeature: CompilerRuntimeFeature;
|
|
356
|
+
declare const keyedListRuntimeFeature: CompilerRuntimeFeature;
|
|
357
|
+
declare const keyedRowsRuntimeFeature: CompilerRuntimeFeature;
|
|
358
|
+
declare const keyedRowsPlainRuntimeFeature: CompilerRuntimeFeature;
|
|
359
|
+
declare const keyedRowsIdentityRuntimeFeature: CompilerRuntimeFeature;
|
|
360
|
+
declare const keyedRowsMembershipRuntimeFeature: CompilerRuntimeFeature;
|
|
361
|
+
declare const keyedRowsMapLookupRuntimeFeature: CompilerRuntimeFeature;
|
|
362
|
+
declare const keyedRowsHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
363
|
+
declare const keyedRowsAppendOnlyRuntimeFeature: CompilerRuntimeFeature;
|
|
364
|
+
declare const keyedRowsPositionHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
365
|
+
declare const keyedRowsBatchPositionHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
366
|
+
declare const keyedRowsWindowPositionHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
367
|
+
declare const keyedRowsReorderHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
368
|
+
declare const keyedRowsPlainReorderHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
369
|
+
declare const keyedRowsMapReorderHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
370
|
+
declare const keyedRowsAllHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
371
|
+
declare const keyedRowsMappedRollingWindowHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
372
|
+
declare const keyedRowsEveryHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
373
|
+
declare const keyedRowsBatchEveryHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
374
|
+
declare const keyedRowsWindowEveryHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
375
|
+
declare const keyedRowsFilterHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
376
|
+
declare const keyedRowsFilterOnlyRuntimeFeature: CompilerRuntimeFeature;
|
|
377
|
+
declare const keyedRowsIdentityFilterHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
378
|
+
declare const keyedRowsIdentityFilterOnlyRuntimeFeature: CompilerRuntimeFeature;
|
|
379
|
+
declare const keyedRowsStructuralAppendHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
380
|
+
declare const keyedRowsStructuralAppendMapHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
381
|
+
declare const keyedRowsStructuralPrependHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
382
|
+
declare const keyedRowsStructuralPrependMapHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
383
|
+
declare const keyedRowsPrependHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
384
|
+
declare const keyedRowsPrependOnlyRuntimeFeature: CompilerRuntimeFeature;
|
|
385
|
+
declare const keyedRowsFilterPrependHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
386
|
+
declare const keyedRowsConditionalRuntimeFeature: CompilerRuntimeFeature;
|
|
387
|
+
declare const keyedRowsConditionalHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
388
|
+
declare const keyedRowsConditionalPositionHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
389
|
+
declare const keyedRowsConditionalBatchPositionHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
390
|
+
declare const keyedRowsConditionalWindowPositionHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
391
|
+
declare const keyedRowsConditionalReorderHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
392
|
+
declare const keyedRowsConditionalAllHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
393
|
+
declare const keyedRowsConditionalMappedRollingWindowHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
394
|
+
declare const keyedRowsConditionalEveryHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
395
|
+
declare const keyedRowsConditionalBatchEveryHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
396
|
+
declare const keyedRowsConditionalWindowEveryHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
397
|
+
declare const keyedRowsConditionalFilterHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
398
|
+
declare const keyedRowsConditionalStructuralAppendHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
399
|
+
declare const keyedRowsConditionalStructuralAppendMapHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
400
|
+
declare const keyedRowsConditionalStructuralPrependHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
401
|
+
declare const keyedRowsConditionalStructuralPrependMapHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
402
|
+
declare const keyedRowsConditionalPrependHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
403
|
+
declare const keyedRowsConditionalFilterPrependHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
404
|
+
declare const keyedRowsHostRuntimeFeature: CompilerRuntimeFeature;
|
|
405
|
+
declare const keyedRowsHostHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
406
|
+
declare const keyedRowsHostPositionHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
407
|
+
declare const keyedRowsHostBatchPositionHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
408
|
+
declare const keyedRowsHostWindowPositionHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
409
|
+
declare const keyedRowsHostReorderHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
410
|
+
declare const keyedRowsHostAllHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
411
|
+
declare const keyedRowsHostMappedRollingWindowHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
412
|
+
declare const keyedRowsHostEveryHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
413
|
+
declare const keyedRowsHostBatchEveryHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
414
|
+
declare const keyedRowsHostWindowEveryHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
415
|
+
declare const keyedRowsHostFilterHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
416
|
+
declare const keyedRowsHostStructuralAppendHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
417
|
+
declare const keyedRowsHostStructuralAppendMapHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
418
|
+
declare const keyedRowsHostStructuralPrependHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
419
|
+
declare const keyedRowsHostStructuralPrependMapHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
420
|
+
declare const keyedRowsHostPrependHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
421
|
+
declare const keyedRowsHostFilterPrependHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
422
|
+
declare const keyedRowsCompleteRuntimeFeature: CompilerRuntimeFeature;
|
|
423
|
+
declare const keyedRowsCompleteHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
424
|
+
declare const keyedRowsCompletePositionHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
425
|
+
declare const keyedRowsCompleteBatchPositionHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
426
|
+
declare const keyedRowsCompleteWindowPositionHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
427
|
+
declare const keyedRowsCompleteReorderHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
428
|
+
declare const keyedRowsCompleteAllHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
429
|
+
declare const keyedRowsCompleteMappedRollingWindowHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
430
|
+
declare const keyedRowsCompleteEveryHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
431
|
+
declare const keyedRowsCompleteBatchEveryHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
432
|
+
declare const keyedRowsCompleteWindowEveryHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
433
|
+
declare const keyedRowsCompleteFilterHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
434
|
+
declare const keyedRowsCompleteStructuralAppendHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
435
|
+
declare const keyedRowsCompleteStructuralAppendMapHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
436
|
+
declare const keyedRowsCompleteStructuralPrependHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
437
|
+
declare const keyedRowsCompleteStructuralPrependMapHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
438
|
+
declare const keyedRowsCompletePrependHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
439
|
+
declare const keyedRowsCompleteFilterPrependHintedRuntimeFeature: CompilerRuntimeFeature;
|
|
440
|
+
declare const keyedRangesRuntimeFeature: CompilerRuntimeFeature;
|
|
441
|
+
declare const mixedRangesRuntimeFeature: CompilerRuntimeFeature;
|
|
442
|
+
declare const componentRuntimeFeature: CompilerRuntimeFeature;
|
|
172
443
|
/**
|
|
173
|
-
*
|
|
444
|
+
* Tree-shakable runtime target emitted by the AOT transform.
|
|
174
445
|
*
|
|
175
446
|
* React owns initial placement, SSR, hydration, props, and event semantics.
|
|
176
|
-
* Compiler cells own local updates and precomputed DOM paths.
|
|
177
|
-
*
|
|
447
|
+
* Compiler cells own local updates and precomputed DOM paths. Structural
|
|
448
|
+
* helpers are installed only when the compiler emitted that boundary kind.
|
|
449
|
+
*/
|
|
450
|
+
declare function createCompiledComponentWithFeatures<Props>(definition: CompiledComponentDefinition<Props>, runtimeFeatures: readonly CompilerRuntimeFeature[]): React.ComponentType<Props>;
|
|
451
|
+
/**
|
|
452
|
+
* Compatibility entry for hand-authored runtime definitions.
|
|
453
|
+
* Compiler output uses createCompiledComponentWithFeatures so unused structural
|
|
454
|
+
* runtimes can be removed from production bundles.
|
|
178
455
|
*/
|
|
179
456
|
declare function createCompiledComponent<Props>(definition: CompiledComponentDefinition<Props>): React.ComponentType<Props>;
|
|
180
457
|
|
|
181
|
-
export { type CompiledComponentDefinition, type CompilerAttributeBinding, type CompilerBinding, type CompilerBlockRuntime, type CompilerCell, type CompilerComponentBlockProps, type CompilerConditionalBlockBinding, type CompilerConditionalBlockProps, type CompilerConditionalRange, type CompilerConditionalRangesBlockProps, type CompilerHostConditionalBinding, type CompilerHostConditionalBlockProps, type CompilerHostConditionalBranch, type CompilerHostElement, type CompilerKeyedListBlockProps, type CompilerKeyedRange, type CompilerKeyedRangesBlockProps, type CompilerKeyedRowBinding, type CompilerKeyedRowConditional, type CompilerKeyedRowConditionalBranch, type CompilerKeyedRowElement, type CompilerKeyedRowEvent, type CompilerKeyedRowsBlockProps, type CompilerStateUpdater, type CompilerStyleBinding, type CompilerTextBinding, createCompiledComponent };
|
|
458
|
+
export { type CompiledComponentDefinition, type CompilerAttributeBinding, type CompilerBinding, type CompilerBlockRuntime, type CompilerCell, type CompilerComponentBlockProps, type CompilerConditionalBlockBinding, type CompilerConditionalBlockProps, type CompilerConditionalRange, type CompilerConditionalRangesBlockProps, type CompilerHostBlock, type CompilerHostConditionalBinding, type CompilerHostConditionalBlockProps, type CompilerHostConditionalBranch, type CompilerHostConditionalRanges, type CompilerHostElement, type CompilerHostKeyedRanges, type CompilerHostMixedRanges, type CompilerKeyedListBlockProps, type CompilerKeyedRange, type CompilerKeyedRangesBlockProps, type CompilerKeyedRowBinding, type CompilerKeyedRowConditional, type CompilerKeyedRowConditionalBranch, type CompilerKeyedRowElement, type CompilerKeyedRowEvent, type CompilerKeyedRowsBlockProps, type CompilerMixedRange, type CompilerMixedRangesBlockProps, type CompilerRuntimeFeature, type CompilerRuntimeFeatureOwner, type CompilerRuntimeReactivity, type CompilerStateUpdater, type CompilerStaticRangeBinding, type CompilerStyleBinding, type CompilerTextBinding, applyCompilerKeyedCollectionMutation, componentRuntimeFeature, conditionalRangesRuntimeFeature, conditionalRuntimeFeature, createCompiledComponent, createCompiledComponentWithFeatures, createCompilerKeyedArrayAppend, createCompilerKeyedArrayBatchInsert, createCompilerKeyedArrayFilter, createCompilerKeyedArrayMapPipeline, createCompilerKeyedArrayMapReorder, createCompilerKeyedArrayMappedRollingWindow, createCompilerKeyedArrayMappedStructuralAppend, createCompilerKeyedArrayMappedStructuralPrepend, createCompilerKeyedArrayPositionUpdate, createCompilerKeyedArrayPrepend, createCompilerKeyedArrayQueuedMapPipeline, createCompilerKeyedArrayReorder, createCompilerKeyedArrayRollingWindow, createCompilerKeyedArrayRollingWindowMapPipeline, createCompilerKeyedArraySlice, createCompilerKeyedArraySort, createCompilerKeyedArrayStructuralAppend, createCompilerKeyedArrayStructuralAppendMapPipeline, createCompilerKeyedArrayStructuralPrepend, createCompilerKeyedArrayStructuralPrependMapPipeline, createCompilerKeyedArrayStructuralReorder, createCompilerKeyedArrayStructuralSort, createCompilerKeyedArrayWindowReplace, createCompilerKeyedCollectionUpdate, createCompilerKeyedMapUpdate, finalizeCompilerKeyedArrayMappedStructuralUpdate, hostConditionalRuntimeFeature, keyedListRuntimeFeature, keyedRangesRuntimeFeature, keyedRowsAllHintedRuntimeFeature, keyedRowsAppendOnlyRuntimeFeature, keyedRowsBatchEveryHintedRuntimeFeature, keyedRowsBatchPositionHintedRuntimeFeature, keyedRowsCompleteAllHintedRuntimeFeature, keyedRowsCompleteBatchEveryHintedRuntimeFeature, keyedRowsCompleteBatchPositionHintedRuntimeFeature, keyedRowsCompleteEveryHintedRuntimeFeature, keyedRowsCompleteFilterHintedRuntimeFeature, keyedRowsCompleteFilterPrependHintedRuntimeFeature, keyedRowsCompleteHintedRuntimeFeature, keyedRowsCompleteMappedRollingWindowHintedRuntimeFeature, keyedRowsCompletePositionHintedRuntimeFeature, keyedRowsCompletePrependHintedRuntimeFeature, keyedRowsCompleteReorderHintedRuntimeFeature, keyedRowsCompleteRuntimeFeature, keyedRowsCompleteStructuralAppendHintedRuntimeFeature, keyedRowsCompleteStructuralAppendMapHintedRuntimeFeature, keyedRowsCompleteStructuralPrependHintedRuntimeFeature, keyedRowsCompleteStructuralPrependMapHintedRuntimeFeature, keyedRowsCompleteWindowEveryHintedRuntimeFeature, keyedRowsCompleteWindowPositionHintedRuntimeFeature, keyedRowsConditionalAllHintedRuntimeFeature, keyedRowsConditionalBatchEveryHintedRuntimeFeature, keyedRowsConditionalBatchPositionHintedRuntimeFeature, keyedRowsConditionalEveryHintedRuntimeFeature, keyedRowsConditionalFilterHintedRuntimeFeature, keyedRowsConditionalFilterPrependHintedRuntimeFeature, keyedRowsConditionalHintedRuntimeFeature, keyedRowsConditionalMappedRollingWindowHintedRuntimeFeature, keyedRowsConditionalPositionHintedRuntimeFeature, keyedRowsConditionalPrependHintedRuntimeFeature, keyedRowsConditionalReorderHintedRuntimeFeature, keyedRowsConditionalRuntimeFeature, keyedRowsConditionalStructuralAppendHintedRuntimeFeature, keyedRowsConditionalStructuralAppendMapHintedRuntimeFeature, keyedRowsConditionalStructuralPrependHintedRuntimeFeature, keyedRowsConditionalStructuralPrependMapHintedRuntimeFeature, keyedRowsConditionalWindowEveryHintedRuntimeFeature, keyedRowsConditionalWindowPositionHintedRuntimeFeature, keyedRowsEveryHintedRuntimeFeature, keyedRowsFilterHintedRuntimeFeature, keyedRowsFilterOnlyRuntimeFeature, keyedRowsFilterPrependHintedRuntimeFeature, keyedRowsHintedRuntimeFeature, keyedRowsHostAllHintedRuntimeFeature, keyedRowsHostBatchEveryHintedRuntimeFeature, keyedRowsHostBatchPositionHintedRuntimeFeature, keyedRowsHostEveryHintedRuntimeFeature, keyedRowsHostFilterHintedRuntimeFeature, keyedRowsHostFilterPrependHintedRuntimeFeature, keyedRowsHostHintedRuntimeFeature, keyedRowsHostMappedRollingWindowHintedRuntimeFeature, keyedRowsHostPositionHintedRuntimeFeature, keyedRowsHostPrependHintedRuntimeFeature, keyedRowsHostReorderHintedRuntimeFeature, keyedRowsHostRuntimeFeature, keyedRowsHostStructuralAppendHintedRuntimeFeature, keyedRowsHostStructuralAppendMapHintedRuntimeFeature, keyedRowsHostStructuralPrependHintedRuntimeFeature, keyedRowsHostStructuralPrependMapHintedRuntimeFeature, keyedRowsHostWindowEveryHintedRuntimeFeature, keyedRowsHostWindowPositionHintedRuntimeFeature, keyedRowsIdentityFilterHintedRuntimeFeature, keyedRowsIdentityFilterOnlyRuntimeFeature, keyedRowsIdentityRuntimeFeature, keyedRowsMapLookupRuntimeFeature, keyedRowsMapReorderHintedRuntimeFeature, keyedRowsMappedRollingWindowHintedRuntimeFeature, keyedRowsMembershipRuntimeFeature, keyedRowsPlainReorderHintedRuntimeFeature, keyedRowsPlainRuntimeFeature, keyedRowsPositionHintedRuntimeFeature, keyedRowsPrependHintedRuntimeFeature, keyedRowsPrependOnlyRuntimeFeature, keyedRowsReorderHintedRuntimeFeature, keyedRowsRuntimeFeature, keyedRowsStructuralAppendHintedRuntimeFeature, keyedRowsStructuralAppendMapHintedRuntimeFeature, keyedRowsStructuralPrependHintedRuntimeFeature, keyedRowsStructuralPrependMapHintedRuntimeFeature, keyedRowsWindowEveryHintedRuntimeFeature, keyedRowsWindowPositionHintedRuntimeFeature, mixedRangesRuntimeFeature };
|