fluid-framework 2.52.0 → 2.53.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +125 -0
- package/api-report/fluid-framework.alpha.api.md +52 -45
- package/api-report/fluid-framework.beta.api.md +4 -4
- package/api-report/fluid-framework.legacy.alpha.api.md +4 -4
- package/api-report/fluid-framework.legacy.public.api.md +4 -4
- package/api-report/fluid-framework.public.api.md +4 -4
- package/dist/alpha.d.ts +2 -1
- package/lib/alpha.d.ts +2 -1
- package/package.json +12 -12
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,130 @@
|
|
|
1
1
|
# fluid-framework
|
|
2
2
|
|
|
3
|
+
## 2.53.0
|
|
4
|
+
|
|
5
|
+
### Minor Changes
|
|
6
|
+
|
|
7
|
+
- TableSchema's "removeColumn" API now removes corresponding cells (alpha) ([#25213](https://github.com/microsoft/FluidFramework/pull/25213)) [b665ba8320d](https://github.com/microsoft/FluidFramework/commit/b665ba8320d9ab6d1b87de81bdf54c2fde20e5c1)
|
|
8
|
+
|
|
9
|
+
Previously, the [removeColumn](https://fluidframework.com/docs/api/fluid-framework/tableschema-namespace/table-interface#removecolumn-methodsignature) API on Table nodes derived from [TableSchema](https://fluidframework.com/docs/api/fluid-framework/tableschema-namespace/) (alpha) only removed the `Column` node from the list of columns tracked by the table.
|
|
10
|
+
To also remove the corresponding cells from the table (which are stored on the `Row` nodes), the user was required to write a custom transaction that removed the column and cells.
|
|
11
|
+
|
|
12
|
+
The motivation for this design was due to performance concerns with transactions.
|
|
13
|
+
Those concerns are still relevant, but the data leak risk of dropping columns without removing corresponding cells seems a greater risk, and we have plans to address the performance issues with transactions.
|
|
14
|
+
|
|
15
|
+
- Adds staged allowed types to SchemaFactoryAlpha ([#25116](https://github.com/microsoft/FluidFramework/pull/25116)) [59baf03ac7f](https://github.com/microsoft/FluidFramework/commit/59baf03ac7f2f2779533c8c63e1de85c01a0d39a)
|
|
16
|
+
|
|
17
|
+
This adds the `staged` API to [`SchemaFactoryAlpha`](https://fluidframework.com/docs/api/fluid-framework/schemafactoryalpha-class).
|
|
18
|
+
Staged allowed types can be used for schema evolution to add members to an [`AllowedTypes`](https://fluidframework.com/docs/api/fluid-framework/allowedtypes-typealias) while supporting cross version collaboration.
|
|
19
|
+
|
|
20
|
+
Staged allowed types are [allowed types](https://fluidframework.com/docs/api/fluid-framework/allowedtypes-typealias) that can be upgraded by [schema upgrades](https://fluidframework.com/docs/api/fluid-framework/treeview-interface#upgradeschema-methodsignature).
|
|
21
|
+
Before being upgraded, any attempt to insert or move a node to a location which requires its type to be upgraded to be valid will throw an error.
|
|
22
|
+
|
|
23
|
+
To add a new member to an `AllowedTypes`, add the type wrapped by `staged`.
|
|
24
|
+
For example, migrating an array which previously supported only numbers to support both numbers and strings would start by deploying a version of the app using `staged`:
|
|
25
|
+
|
|
26
|
+
```typescript
|
|
27
|
+
class TestArray extends schemaFactoryAlpha.arrayAlpha("TestArray", [
|
|
28
|
+
SchemaFactoryAlpha.number,
|
|
29
|
+
SchemaFactoryAlpha.staged(SchemaFactoryAlpha.string),
|
|
30
|
+
]) {}
|
|
31
|
+
```
|
|
32
|
+
|
|
33
|
+
Once enough clients have this code update, it is safe to allow writing strings to the array.
|
|
34
|
+
To allow writing strings to the array, a code change must be made to remove the staged annotation:
|
|
35
|
+
|
|
36
|
+
```typescript
|
|
37
|
+
class TestArray extends schemaFactoryAlpha.arrayAlpha("TestArray", [
|
|
38
|
+
schemaFactoryAlpha.number,
|
|
39
|
+
schemaFactoryAlpha.string,
|
|
40
|
+
]) {}
|
|
41
|
+
```
|
|
42
|
+
|
|
43
|
+
Then when opening old documents [upgradeSchema](https://fluidframework.com/docs/api/fluid-framework/treeview-interface#upgradeschema-methodsignature) is used to upgrade the stored schema:
|
|
44
|
+
|
|
45
|
+
```typescript
|
|
46
|
+
view.upgradeSchema();
|
|
47
|
+
```
|
|
48
|
+
|
|
49
|
+
The `@alpha` API [extractPersistedSchema](https://fluidframework.com/docs/api/fluid-framework#extractpersistedschema-function) now takes the schema as an `ImplicitAnnotatedFieldSchema` and an additional parameter to filter which staged upgrades it includes.
|
|
50
|
+
|
|
51
|
+
Below is a full example of how the schema migration process works.
|
|
52
|
+
This can also be found in the [tests](https://github.com/microsoft/FluidFramework/blob/main/packages/dds/tree/src/test/simple-tree/api/stagedSchemaUpgrade.spec.ts).
|
|
53
|
+
|
|
54
|
+
```typescript
|
|
55
|
+
// Schema A: only number allowed
|
|
56
|
+
const schemaA = SchemaFactoryAlpha.optional([SchemaFactoryAlpha.number]);
|
|
57
|
+
|
|
58
|
+
// Schema B: number or string (string is staged)
|
|
59
|
+
const schemaB = SchemaFactoryAlpha.optional([
|
|
60
|
+
SchemaFactoryAlpha.number,
|
|
61
|
+
SchemaFactoryAlpha.staged(SchemaFactoryAlpha.string),
|
|
62
|
+
]);
|
|
63
|
+
|
|
64
|
+
// Schema C: number or string, both fully allowed
|
|
65
|
+
const schemaC = SchemaFactoryAlpha.optional([
|
|
66
|
+
SchemaFactoryAlpha.number,
|
|
67
|
+
SchemaFactoryAlpha.string,
|
|
68
|
+
]);
|
|
69
|
+
|
|
70
|
+
// Initialize with schema A.
|
|
71
|
+
const configA = new TreeViewConfiguration({
|
|
72
|
+
schema: schemaA,
|
|
73
|
+
});
|
|
74
|
+
const viewA = treeA.viewWith(configA);
|
|
75
|
+
viewA.initialize(5);
|
|
76
|
+
|
|
77
|
+
// Since we are running all the different versions of the app in the same process making changes synchronously,
|
|
78
|
+
// an explicit flush is needed to make them available to each other.
|
|
79
|
+
synchronizeTrees();
|
|
80
|
+
|
|
81
|
+
assert.deepEqual(viewA.root, 5);
|
|
82
|
+
|
|
83
|
+
// View the same document with a second tree using schema B.
|
|
84
|
+
const configB = new TreeViewConfiguration({
|
|
85
|
+
schema: schemaB,
|
|
86
|
+
});
|
|
87
|
+
const viewB = treeB.viewWith(configB);
|
|
88
|
+
// B cannot write strings to the root.
|
|
89
|
+
assert.throws(() => (viewB.root = "test"));
|
|
90
|
+
|
|
91
|
+
// View the same document with a third tree using schema C.
|
|
92
|
+
const configC = new TreeViewConfiguration({
|
|
93
|
+
schema: schemaC,
|
|
94
|
+
});
|
|
95
|
+
const viewC = treeC.viewWith(configC);
|
|
96
|
+
// Upgrade to schema C
|
|
97
|
+
viewC.upgradeSchema();
|
|
98
|
+
// Use the newly enabled schema.
|
|
99
|
+
viewC.root = "test";
|
|
100
|
+
|
|
101
|
+
synchronizeTrees();
|
|
102
|
+
|
|
103
|
+
// View A is now incompatible with the stored schema:
|
|
104
|
+
assert.equal(viewA.compatibility.canView, false);
|
|
105
|
+
|
|
106
|
+
// View B can still read the document, and now sees the string root which relies on the staged schema.
|
|
107
|
+
assert.deepEqual(viewB.root, "test");
|
|
108
|
+
```
|
|
109
|
+
|
|
110
|
+
- Allow edits in arrays to be concurrent to dependent edits of transactions with violated constraints ([#25191](https://github.com/microsoft/FluidFramework/pull/25191)) [ef64bae6ab2](https://github.com/microsoft/FluidFramework/commit/ef64bae6ab2848c67d778d14ad56ae021f54ac7a)
|
|
111
|
+
|
|
112
|
+
Before this release, making concurrent edits to an array could lead to assertion error `0x8a2` being thrown if the following conditions were met:
|
|
113
|
+
|
|
114
|
+
- Some edit `e1` was a transaction with a constraint that turned out to be violated by edits concurrent to (and sequenced before) `e1`
|
|
115
|
+
- Some edit `e2` was dependent on `e1` (from before the violation of its constraint)
|
|
116
|
+
- Some edit `e3` was concurrent to and sequenced after both `e1` and `e2`
|
|
117
|
+
- `e3` was either concurrent to or the revert of some other edit `e0` that predated `e1`, `e2`, and `e3`.
|
|
118
|
+
- `e0` and `e2` made edits to the same gap (that is, in the same space between nodes) in the sequence/array.
|
|
119
|
+
|
|
120
|
+
After this release, these scenarios will work as expected (that is, no assertion error thrown).
|
|
121
|
+
|
|
122
|
+
- Export TreeNode not only as a type ([#25226](https://github.com/microsoft/FluidFramework/pull/25226)) [eefb9522c01](https://github.com/microsoft/FluidFramework/commit/eefb9522c019ac68d8b4f40d7134116c78a1f2a5)
|
|
123
|
+
|
|
124
|
+
`TreeNode` can now be used as a runtime object.
|
|
125
|
+
This enables checking if an object is a `TreeNode` with `instanceof`.
|
|
126
|
+
`TreeNode` has customized `instanceof` support so it can detect `TreeNode` instances, even if they hide their prototype like [POJO mode nodes](https://fluidframework.com/docs/api/fluid-framework/schemafactory-class#schemafactory-remarks) do.
|
|
127
|
+
|
|
3
128
|
## 2.52.0
|
|
4
129
|
|
|
5
130
|
### Minor Changes
|
|
@@ -15,15 +15,16 @@ export function adaptEnum<TScope extends string, const TEnum extends Record<stri
|
|
|
15
15
|
}, Record<string, never>, true, Record<string, never>, undefined>; }[keyof TEnum]>;
|
|
16
16
|
};
|
|
17
17
|
|
|
18
|
-
// @alpha
|
|
18
|
+
// @alpha @input
|
|
19
19
|
export interface AllowedTypeMetadata {
|
|
20
20
|
readonly custom?: unknown;
|
|
21
|
+
readonly stagedSchemaUpgrade?: SchemaUpgrade;
|
|
21
22
|
}
|
|
22
23
|
|
|
23
24
|
// @public @system
|
|
24
25
|
export type AllowedTypes = readonly LazyItem<TreeNodeSchema>[];
|
|
25
26
|
|
|
26
|
-
// @alpha
|
|
27
|
+
// @alpha @input
|
|
27
28
|
export interface AllowedTypesMetadata {
|
|
28
29
|
readonly custom?: unknown;
|
|
29
30
|
}
|
|
@@ -31,16 +32,16 @@ export interface AllowedTypesMetadata {
|
|
|
31
32
|
// @alpha
|
|
32
33
|
export function allowUnused<T>(t?: T): void;
|
|
33
34
|
|
|
34
|
-
// @alpha
|
|
35
|
+
// @alpha @sealed
|
|
35
36
|
export interface AnnotatedAllowedType<T = LazyItem<TreeNodeSchema>> {
|
|
36
37
|
readonly metadata: AllowedTypeMetadata;
|
|
37
38
|
readonly type: T;
|
|
38
39
|
}
|
|
39
40
|
|
|
40
|
-
// @alpha
|
|
41
|
-
export interface AnnotatedAllowedTypes {
|
|
41
|
+
// @alpha @sealed
|
|
42
|
+
export interface AnnotatedAllowedTypes<T = LazyItem<TreeNodeSchema>> {
|
|
42
43
|
readonly metadata: AllowedTypesMetadata;
|
|
43
|
-
readonly types: readonly
|
|
44
|
+
readonly types: readonly AnnotatedAllowedType<T>[];
|
|
44
45
|
}
|
|
45
46
|
|
|
46
47
|
// @public @system
|
|
@@ -205,7 +206,7 @@ export function evaluateLazySchema<T extends TreeNodeSchema>(value: LazyItem<T>)
|
|
|
205
206
|
type ExtractItemType<Item extends LazyItem> = Item extends () => infer Result ? Result : Item;
|
|
206
207
|
|
|
207
208
|
// @alpha
|
|
208
|
-
export function extractPersistedSchema(schema:
|
|
209
|
+
export function extractPersistedSchema(schema: ImplicitAnnotatedFieldSchema, oldestCompatibleClient: FluidClientVersion, includeStaged: (upgrade: SchemaUpgrade) => boolean): JsonCompatible;
|
|
209
210
|
|
|
210
211
|
// @alpha @system
|
|
211
212
|
export type FactoryContent = IFluidHandle | string | number | boolean | null | Iterable<readonly [string, InsertableContent]> | readonly InsertableContent[] | FactoryContentObject;
|
|
@@ -605,10 +606,10 @@ export interface IMember {
|
|
|
605
606
|
// @public
|
|
606
607
|
export type ImplicitAllowedTypes = AllowedTypes | TreeNodeSchema;
|
|
607
608
|
|
|
608
|
-
// @alpha
|
|
609
|
+
// @alpha @input
|
|
609
610
|
export type ImplicitAnnotatedAllowedTypes = TreeNodeSchema | AnnotatedAllowedType | AnnotatedAllowedTypes | readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[];
|
|
610
611
|
|
|
611
|
-
// @alpha
|
|
612
|
+
// @alpha @input
|
|
612
613
|
export type ImplicitAnnotatedFieldSchema = FieldSchema | ImplicitAnnotatedAllowedTypes;
|
|
613
614
|
|
|
614
615
|
// @public
|
|
@@ -773,16 +774,14 @@ export namespace JsonAsTree {
|
|
|
773
774
|
export class JsonObject extends _APIExtractorWorkaroundObjectBase {
|
|
774
775
|
}
|
|
775
776
|
const // @system
|
|
776
|
-
_APIExtractorWorkaroundObjectBase: TreeNodeSchemaClass<"com.fluidframework.json.object", NodeKind.Record,
|
|
777
|
+
_APIExtractorWorkaroundObjectBase: TreeNodeSchemaClass<"com.fluidframework.json.object", NodeKind.Record, TreeRecordNodeUnsafe<readonly [LeafSchema<"null", null>, LeafSchema<"number", number>, LeafSchema<"string", string>, LeafSchema<"boolean", boolean>, () => typeof JsonObject, () => typeof Array]> & WithType<"com.fluidframework.json.object", NodeKind.Record, unknown>, {
|
|
777
778
|
readonly [x: string]: string | number | JsonObject | Array | System_Unsafe.InsertableTypedNodeUnsafe<LeafSchema<"boolean", boolean>, LeafSchema<"boolean", boolean>> | null;
|
|
778
779
|
}, false, readonly [LeafSchema<"null", null>, LeafSchema<"number", number>, LeafSchema<"string", string>, LeafSchema<"boolean", boolean>, () => typeof JsonObject, () => typeof Array], undefined>;
|
|
779
|
-
// (undocumented)
|
|
780
780
|
export type Primitive = TreeNodeFromImplicitAllowedTypes<typeof Primitive>;
|
|
781
781
|
// @system
|
|
782
782
|
export type _RecursiveArrayWorkaroundJsonArray = FixRecursiveArraySchema<typeof Array>;
|
|
783
783
|
const // @system
|
|
784
|
-
_APIExtractorWorkaroundArrayBase:
|
|
785
|
-
// (undocumented)
|
|
784
|
+
_APIExtractorWorkaroundArrayBase: ArrayNodeCustomizableSchemaUnsafe<"com.fluidframework.json.array", readonly [LeafSchema<"null", null>, LeafSchema<"number", number>, LeafSchema<"string", string>, LeafSchema<"boolean", boolean>, () => typeof JsonObject, () => typeof Array], unknown>;
|
|
786
785
|
export type Tree = TreeNodeFromImplicitAllowedTypes<typeof Tree>;
|
|
787
786
|
}
|
|
788
787
|
|
|
@@ -980,10 +979,8 @@ export interface NodeSchemaOptionsAlpha<out TCustomMetadata = unknown> extends N
|
|
|
980
979
|
// @alpha
|
|
981
980
|
export const noopValidator: JsonValidator;
|
|
982
981
|
|
|
983
|
-
// @alpha
|
|
984
|
-
export interface NormalizedAnnotatedAllowedTypes {
|
|
985
|
-
readonly metadata: AllowedTypesMetadata;
|
|
986
|
-
readonly types: readonly AnnotatedAllowedType<TreeNodeSchema>[];
|
|
982
|
+
// @alpha @sealed
|
|
983
|
+
export interface NormalizedAnnotatedAllowedTypes extends AnnotatedAllowedTypes<TreeNodeSchema> {
|
|
987
984
|
}
|
|
988
985
|
|
|
989
986
|
// @public @system
|
|
@@ -1140,11 +1137,11 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
|
|
|
1140
1137
|
readonly boolean: LeafSchema<"boolean", boolean>;
|
|
1141
1138
|
static readonly boolean: LeafSchema<"boolean", boolean>;
|
|
1142
1139
|
protected getStructuralType(fullName: string, types: TreeNodeSchema | readonly TreeNodeSchema[], builder: () => TreeNodeSchema): TreeNodeSchema;
|
|
1143
|
-
readonly handle: LeafSchema<"handle",
|
|
1144
|
-
static readonly handle: LeafSchema<"handle",
|
|
1140
|
+
readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
|
|
1141
|
+
static readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
|
|
1145
1142
|
get identifier(): FieldSchema<FieldKind.Identifier, typeof SchemaFactory.string>;
|
|
1146
|
-
readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle",
|
|
1147
|
-
static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle",
|
|
1143
|
+
readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
|
|
1144
|
+
static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
|
|
1148
1145
|
map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchemaNonClass<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
|
|
1149
1146
|
map<Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
|
|
1150
1147
|
mapRecursive<Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, System_Unsafe.TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map, unknown>, {
|
|
@@ -1178,9 +1175,9 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
|
|
|
1178
1175
|
export class SchemaFactoryAlpha<out TScope extends string | undefined = string | undefined, TName extends number | string = string> extends SchemaFactory<TScope, TName> {
|
|
1179
1176
|
arrayAlpha<const Name extends TName, const T extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): ArrayNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata>;
|
|
1180
1177
|
arrayRecursive<const Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): ArrayNodeCustomizableSchemaUnsafe<ScopedSchemaName<TScope, Name>, T, TCustomMetadata>;
|
|
1181
|
-
static readonly identifier: <const TCustomMetadata = unknown>(props?: Omit<
|
|
1182
|
-
static readonly leaves: readonly [
|
|
1183
|
-
readonly leaves: readonly [
|
|
1178
|
+
static readonly identifier: <const TCustomMetadata = unknown>(props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlpha<FieldKind.Identifier, LeafSchema<"string", string> & SimpleLeafNodeSchema, TCustomMetadata>;
|
|
1179
|
+
static readonly leaves: readonly [LeafSchema<"string", string> & SimpleLeafNodeSchema, LeafSchema<"number", number> & SimpleLeafNodeSchema, LeafSchema<"boolean", boolean> & SimpleLeafNodeSchema, LeafSchema<"null", null> & SimpleLeafNodeSchema, LeafSchema<"handle", IFluidHandle_2<unknown>> & SimpleLeafNodeSchema];
|
|
1180
|
+
readonly leaves: readonly [LeafSchema<"string", string> & SimpleLeafNodeSchema, LeafSchema<"number", number> & SimpleLeafNodeSchema, LeafSchema<"boolean", boolean> & SimpleLeafNodeSchema, LeafSchema<"null", null> & SimpleLeafNodeSchema, LeafSchema<"handle", IFluidHandle_2<unknown>> & SimpleLeafNodeSchema];
|
|
1184
1181
|
mapAlpha<Name extends TName, const T extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): MapNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata>;
|
|
1185
1182
|
mapRecursive<Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): MapNodeCustomizableSchemaUnsafe<ScopedSchemaName<TScope, Name>, T, TCustomMetadata>;
|
|
1186
1183
|
objectAlpha<const Name extends TName, const T extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>, const TCustomMetadata = unknown>(name: Name, fields: T, options?: SchemaFactoryObjectOptions<TCustomMetadata>): ObjectNodeSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata> & {
|
|
@@ -1188,15 +1185,15 @@ export class SchemaFactoryAlpha<out TScope extends string | undefined = string |
|
|
|
1188
1185
|
};
|
|
1189
1186
|
objectRecursive<const Name extends TName, const T extends RestrictiveStringRecord<System_Unsafe.ImplicitFieldSchemaUnsafe>, const TCustomMetadata = unknown>(name: Name, t: T, options?: SchemaFactoryObjectOptions<TCustomMetadata>): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Object, System_Unsafe.TreeObjectNodeUnsafe<T, ScopedSchemaName<TScope, Name>>, object & System_Unsafe.InsertableObjectFromSchemaRecordUnsafe<T>, false, T, never, TCustomMetadata> & SimpleObjectNodeSchema<TCustomMetadata> & Pick<ObjectNodeSchema, "fields">;
|
|
1190
1187
|
static readonly optional: {
|
|
1191
|
-
<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<
|
|
1192
|
-
<const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<
|
|
1188
|
+
<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Optional, T, TCustomMetadata>;
|
|
1189
|
+
<const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<FieldPropsAlpha<TCustomMetadata_1>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Optional, UnannotateImplicitAllowedTypes<T_1>, TCustomMetadata_1>;
|
|
1193
1190
|
};
|
|
1194
1191
|
readonly optional: {
|
|
1195
|
-
<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<
|
|
1196
|
-
<const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<
|
|
1192
|
+
<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Optional, T, TCustomMetadata>;
|
|
1193
|
+
<const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<FieldPropsAlpha<TCustomMetadata_1>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Optional, UnannotateImplicitAllowedTypes<T_1>, TCustomMetadata_1>;
|
|
1197
1194
|
};
|
|
1198
|
-
static readonly optionalRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<
|
|
1199
|
-
readonly optionalRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<
|
|
1195
|
+
static readonly optionalRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlphaUnsafe<FieldKind.Optional, T, TCustomMetadata>;
|
|
1196
|
+
readonly optionalRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlphaUnsafe<FieldKind.Optional, T, TCustomMetadata>;
|
|
1200
1197
|
record<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchemaNonClass<ScopedSchemaName<TScope, `Record<${string}>`>, NodeKind.Record, TreeRecordNode<T> & WithType<ScopedSchemaName<TScope, `Record<${string}>`>, NodeKind.Record>, RecordNodeInsertableData<T>, true, T, undefined>;
|
|
1201
1198
|
record<const Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Record, TreeRecordNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Record>, RecordNodeInsertableData<T>, true, T, undefined>;
|
|
1202
1199
|
recordAlpha<const Name extends TName, const T extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): RecordNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata>;
|
|
@@ -1204,16 +1201,18 @@ export class SchemaFactoryAlpha<out TScope extends string | undefined = string |
|
|
|
1204
1201
|
readonly [x: string]: System_Unsafe.InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>;
|
|
1205
1202
|
}, false, T, undefined>;
|
|
1206
1203
|
static readonly required: {
|
|
1207
|
-
<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<
|
|
1208
|
-
<const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<
|
|
1204
|
+
<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Required, T, TCustomMetadata>;
|
|
1205
|
+
<const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<FieldPropsAlpha<TCustomMetadata_1>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Required, UnannotateImplicitAllowedTypes<T_1>, TCustomMetadata_1>;
|
|
1209
1206
|
};
|
|
1210
1207
|
readonly required: {
|
|
1211
|
-
<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<
|
|
1212
|
-
<const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<
|
|
1208
|
+
<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Required, T, TCustomMetadata>;
|
|
1209
|
+
<const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<FieldPropsAlpha<TCustomMetadata_1>, "defaultProvider"> | undefined): FieldSchemaAlpha<FieldKind.Required, UnannotateImplicitAllowedTypes<T_1>, TCustomMetadata_1>;
|
|
1213
1210
|
};
|
|
1214
|
-
static readonly requiredRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<
|
|
1215
|
-
readonly requiredRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<
|
|
1211
|
+
static readonly requiredRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlphaUnsafe<FieldKind.Required, T, TCustomMetadata>;
|
|
1212
|
+
readonly requiredRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined) => FieldSchemaAlphaUnsafe<FieldKind.Required, T, TCustomMetadata>;
|
|
1216
1213
|
scopedFactory<const T extends TName, TNameInner extends number | string = string>(name: T): SchemaFactoryAlpha<ScopedSchemaName<TScope, T>, TNameInner>;
|
|
1214
|
+
static staged: <const T extends LazyItem<TreeNodeSchema>>(t: T | AnnotatedAllowedType<T>) => AnnotatedAllowedType<T>;
|
|
1215
|
+
staged: <const T extends LazyItem<TreeNodeSchema>>(t: T | AnnotatedAllowedType<T>) => AnnotatedAllowedType<T>;
|
|
1217
1216
|
}
|
|
1218
1217
|
|
|
1219
1218
|
// @alpha
|
|
@@ -1241,6 +1240,17 @@ export interface SchemaStatics {
|
|
|
1241
1240
|
readonly string: LeafSchema<"string", string>;
|
|
1242
1241
|
}
|
|
1243
1242
|
|
|
1243
|
+
// @alpha @sealed @system
|
|
1244
|
+
export interface SchemaStaticsAlpha {
|
|
1245
|
+
staged: <const T extends LazyItem<TreeNodeSchema>>(t: T | AnnotatedAllowedType<T>) => AnnotatedAllowedType<T>;
|
|
1246
|
+
}
|
|
1247
|
+
|
|
1248
|
+
// @alpha @sealed
|
|
1249
|
+
export class SchemaUpgrade {
|
|
1250
|
+
// (undocumented)
|
|
1251
|
+
protected _typeCheck: MakeNominal;
|
|
1252
|
+
}
|
|
1253
|
+
|
|
1244
1254
|
// @alpha @input
|
|
1245
1255
|
export interface SchemaValidationFunction<Schema extends TSchema> {
|
|
1246
1256
|
check(data: unknown): data is Static<Schema>;
|
|
@@ -1358,7 +1368,7 @@ export namespace System_TableSchema {
|
|
|
1358
1368
|
props: InsertableTreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TPropsSchema>>;
|
|
1359
1369
|
}), true, {
|
|
1360
1370
|
readonly props: TPropsSchema;
|
|
1361
|
-
readonly id: FieldSchema_2<
|
|
1371
|
+
readonly id: FieldSchema_2<FieldKind_2.Identifier, LeafSchema_2<"string", string>, unknown>;
|
|
1362
1372
|
}>;
|
|
1363
1373
|
// @system
|
|
1364
1374
|
export type CreateRowOptionsBase<TSchemaFactory extends SchemaFactoryAlpha = SchemaFactoryAlpha, TCell extends ImplicitAllowedTypes = ImplicitAllowedTypes> = OptionsWithSchemaFactory<TSchemaFactory> & OptionsWithCellSchema<TCell>;
|
|
@@ -1372,8 +1382,8 @@ export namespace System_TableSchema {
|
|
|
1372
1382
|
props: InsertableTreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TPropsSchema>>;
|
|
1373
1383
|
}), true, {
|
|
1374
1384
|
readonly props: TPropsSchema;
|
|
1375
|
-
readonly id: FieldSchema_2<
|
|
1376
|
-
readonly cells:
|
|
1385
|
+
readonly id: FieldSchema_2<FieldKind_2.Identifier, LeafSchema_2<"string", string>, unknown>;
|
|
1386
|
+
readonly cells: FieldSchemaAlpha_2<FieldKind_2.Required, TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Record, TreeRecordNode_2<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Record, unknown>, RecordNodeInsertableData_2<TCellSchema>, true, TCellSchema, undefined>, unknown>;
|
|
1377
1387
|
}>;
|
|
1378
1388
|
// @system
|
|
1379
1389
|
export function createTableSchema<const TInputScope extends string | undefined, const TCellSchema extends ImplicitAllowedTypes, const TColumnSchema extends ColumnSchemaBase<TInputScope, TCellSchema>, const TRowSchema extends RowSchemaBase<TInputScope, TCellSchema>>(inputSchemaFactory: SchemaFactoryAlpha<TInputScope>, _cellSchema: TCellSchema, columnSchema: TColumnSchema, rowSchema: TRowSchema): TreeNodeSchemaCore_2<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table">, NodeKind.Object, true, {
|
|
@@ -1933,21 +1943,18 @@ const typeNameSymbol: unique symbol;
|
|
|
1933
1943
|
export const typeSchemaSymbol: unique symbol;
|
|
1934
1944
|
|
|
1935
1945
|
// @alpha @system
|
|
1936
|
-
export type UnannotateAllowedType<T extends AnnotatedAllowedType | LazyItem<TreeNodeSchema>> = T extends AnnotatedAllowedType<infer X> ?
|
|
1937
|
-
|
|
1938
|
-
// @alpha @system
|
|
1939
|
-
export type UnannotateAllowedTypeOrLazyItem<T extends AnnotatedAllowedType | LazyItem<TreeNodeSchema>> = T extends AnnotatedAllowedType<infer X> ? X : T;
|
|
1946
|
+
export type UnannotateAllowedType<T extends AnnotatedAllowedType | LazyItem<TreeNodeSchema>> = T extends AnnotatedAllowedType<infer X> ? X : T;
|
|
1940
1947
|
|
|
1941
1948
|
// @alpha @system
|
|
1942
1949
|
export type UnannotateAllowedTypes<T extends AnnotatedAllowedTypes> = UnannotateAllowedTypesList<T["types"]>;
|
|
1943
1950
|
|
|
1944
1951
|
// @alpha @system
|
|
1945
1952
|
export type UnannotateAllowedTypesList<T extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[]> = {
|
|
1946
|
-
[I in keyof T]:
|
|
1953
|
+
[I in keyof T]: UnannotateAllowedType<T[I]>;
|
|
1947
1954
|
};
|
|
1948
1955
|
|
|
1949
1956
|
// @alpha @system
|
|
1950
|
-
export type UnannotateImplicitAllowedTypes<T extends ImplicitAnnotatedAllowedTypes> = T extends AnnotatedAllowedTypes ? UnannotateAllowedTypes<T> : T extends AnnotatedAllowedType ?
|
|
1957
|
+
export type UnannotateImplicitAllowedTypes<T extends ImplicitAnnotatedAllowedTypes> = T extends AnnotatedAllowedTypes ? UnannotateAllowedTypes<T> : T extends AnnotatedAllowedType ? UnannotateAllowedTypesList<[T]> : T extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[] ? UnannotateAllowedTypesList<T> : T extends TreeNodeSchema ? T : ImplicitAllowedTypes;
|
|
1951
1958
|
|
|
1952
1959
|
// @alpha @system
|
|
1953
1960
|
export type UnannotateImplicitFieldSchema<T extends ImplicitAnnotatedFieldSchema> = T extends ImplicitAnnotatedAllowedTypes ? UnannotateImplicitAllowedTypes<T> : T;
|
|
@@ -699,11 +699,11 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
|
|
|
699
699
|
readonly boolean: LeafSchema<"boolean", boolean>;
|
|
700
700
|
static readonly boolean: LeafSchema<"boolean", boolean>;
|
|
701
701
|
protected getStructuralType(fullName: string, types: TreeNodeSchema | readonly TreeNodeSchema[], builder: () => TreeNodeSchema): TreeNodeSchema;
|
|
702
|
-
readonly handle: LeafSchema<"handle",
|
|
703
|
-
static readonly handle: LeafSchema<"handle",
|
|
702
|
+
readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
|
|
703
|
+
static readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
|
|
704
704
|
get identifier(): FieldSchema<FieldKind.Identifier, typeof SchemaFactory.string>;
|
|
705
|
-
readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle",
|
|
706
|
-
static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle",
|
|
705
|
+
readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
|
|
706
|
+
static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
|
|
707
707
|
map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchemaNonClass<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
|
|
708
708
|
map<Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
|
|
709
709
|
mapRecursive<Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, System_Unsafe.TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map, unknown>, {
|
|
@@ -961,11 +961,11 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
|
|
|
961
961
|
readonly boolean: LeafSchema<"boolean", boolean>;
|
|
962
962
|
static readonly boolean: LeafSchema<"boolean", boolean>;
|
|
963
963
|
protected getStructuralType(fullName: string, types: TreeNodeSchema | readonly TreeNodeSchema[], builder: () => TreeNodeSchema): TreeNodeSchema;
|
|
964
|
-
readonly handle: LeafSchema<"handle",
|
|
965
|
-
static readonly handle: LeafSchema<"handle",
|
|
964
|
+
readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
|
|
965
|
+
static readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
|
|
966
966
|
get identifier(): FieldSchema<FieldKind.Identifier, typeof SchemaFactory.string>;
|
|
967
|
-
readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle",
|
|
968
|
-
static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle",
|
|
967
|
+
readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
|
|
968
|
+
static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
|
|
969
969
|
map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchemaNonClass<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
|
|
970
970
|
map<Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
|
|
971
971
|
mapRecursive<Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, System_Unsafe.TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map, unknown>, {
|
|
@@ -703,11 +703,11 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
|
|
|
703
703
|
readonly boolean: LeafSchema<"boolean", boolean>;
|
|
704
704
|
static readonly boolean: LeafSchema<"boolean", boolean>;
|
|
705
705
|
protected getStructuralType(fullName: string, types: TreeNodeSchema | readonly TreeNodeSchema[], builder: () => TreeNodeSchema): TreeNodeSchema;
|
|
706
|
-
readonly handle: LeafSchema<"handle",
|
|
707
|
-
static readonly handle: LeafSchema<"handle",
|
|
706
|
+
readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
|
|
707
|
+
static readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
|
|
708
708
|
get identifier(): FieldSchema<FieldKind.Identifier, typeof SchemaFactory.string>;
|
|
709
|
-
readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle",
|
|
710
|
-
static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle",
|
|
709
|
+
readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
|
|
710
|
+
static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
|
|
711
711
|
map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchemaNonClass<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
|
|
712
712
|
map<Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
|
|
713
713
|
mapRecursive<Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, System_Unsafe.TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map, unknown>, {
|
|
@@ -669,11 +669,11 @@ export class SchemaFactory<out TScope extends string | undefined = string | unde
|
|
|
669
669
|
readonly boolean: LeafSchema<"boolean", boolean>;
|
|
670
670
|
static readonly boolean: LeafSchema<"boolean", boolean>;
|
|
671
671
|
protected getStructuralType(fullName: string, types: TreeNodeSchema | readonly TreeNodeSchema[], builder: () => TreeNodeSchema): TreeNodeSchema;
|
|
672
|
-
readonly handle: LeafSchema<"handle",
|
|
673
|
-
static readonly handle: LeafSchema<"handle",
|
|
672
|
+
readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
|
|
673
|
+
static readonly handle: LeafSchema<"handle", IFluidHandle_2<unknown>>;
|
|
674
674
|
get identifier(): FieldSchema<FieldKind.Identifier, typeof SchemaFactory.string>;
|
|
675
|
-
readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle",
|
|
676
|
-
static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle",
|
|
675
|
+
readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
|
|
676
|
+
static readonly leaves: readonly [LeafSchema<"string", string>, LeafSchema<"number", number>, LeafSchema<"boolean", boolean>, LeafSchema<"null", null>, LeafSchema<"handle", IFluidHandle_2<unknown>>];
|
|
677
677
|
map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(allowedTypes: T): TreeNodeSchemaNonClass<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
|
|
678
678
|
map<Name extends TName, const T extends ImplicitAllowedTypes>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>, MapNodeInsertableData<T>, true, T, undefined>;
|
|
679
679
|
mapRecursive<Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe>(name: Name, allowedTypes: T): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Map, System_Unsafe.TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map, unknown>, {
|
package/dist/alpha.d.ts
CHANGED
|
@@ -215,6 +215,8 @@ export {
|
|
|
215
215
|
RunTransactionParams,
|
|
216
216
|
SchemaFactoryAlpha,
|
|
217
217
|
SchemaFactoryObjectOptions,
|
|
218
|
+
SchemaStaticsAlpha,
|
|
219
|
+
SchemaUpgrade,
|
|
218
220
|
SchemaValidationFunction,
|
|
219
221
|
SharedTreeFormatOptions,
|
|
220
222
|
SharedTreeFormatVersion,
|
|
@@ -254,7 +256,6 @@ export {
|
|
|
254
256
|
TreeViewAlpha,
|
|
255
257
|
TreeViewConfigurationAlpha,
|
|
256
258
|
UnannotateAllowedType,
|
|
257
|
-
UnannotateAllowedTypeOrLazyItem,
|
|
258
259
|
UnannotateAllowedTypes,
|
|
259
260
|
UnannotateAllowedTypesList,
|
|
260
261
|
UnannotateImplicitAllowedTypes,
|
package/lib/alpha.d.ts
CHANGED
|
@@ -215,6 +215,8 @@ export {
|
|
|
215
215
|
RunTransactionParams,
|
|
216
216
|
SchemaFactoryAlpha,
|
|
217
217
|
SchemaFactoryObjectOptions,
|
|
218
|
+
SchemaStaticsAlpha,
|
|
219
|
+
SchemaUpgrade,
|
|
218
220
|
SchemaValidationFunction,
|
|
219
221
|
SharedTreeFormatOptions,
|
|
220
222
|
SharedTreeFormatVersion,
|
|
@@ -254,7 +256,6 @@ export {
|
|
|
254
256
|
TreeViewAlpha,
|
|
255
257
|
TreeViewConfigurationAlpha,
|
|
256
258
|
UnannotateAllowedType,
|
|
257
|
-
UnannotateAllowedTypeOrLazyItem,
|
|
258
259
|
UnannotateAllowedTypes,
|
|
259
260
|
UnannotateAllowedTypesList,
|
|
260
261
|
UnannotateImplicitAllowedTypes,
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "fluid-framework",
|
|
3
|
-
"version": "2.
|
|
3
|
+
"version": "2.53.0",
|
|
4
4
|
"description": "The main entry point into Fluid Framework public packages",
|
|
5
5
|
"homepage": "https://fluidframework.com",
|
|
6
6
|
"repository": {
|
|
@@ -57,17 +57,17 @@
|
|
|
57
57
|
"main": "lib/index.js",
|
|
58
58
|
"types": "lib/public.d.ts",
|
|
59
59
|
"dependencies": {
|
|
60
|
-
"@fluidframework/container-definitions": "~2.
|
|
61
|
-
"@fluidframework/container-loader": "~2.
|
|
62
|
-
"@fluidframework/core-interfaces": "~2.
|
|
63
|
-
"@fluidframework/core-utils": "~2.
|
|
64
|
-
"@fluidframework/driver-definitions": "~2.
|
|
65
|
-
"@fluidframework/fluid-static": "~2.
|
|
66
|
-
"@fluidframework/map": "~2.
|
|
67
|
-
"@fluidframework/runtime-utils": "~2.
|
|
68
|
-
"@fluidframework/sequence": "~2.
|
|
69
|
-
"@fluidframework/shared-object-base": "~2.
|
|
70
|
-
"@fluidframework/tree": "~2.
|
|
60
|
+
"@fluidframework/container-definitions": "~2.53.0",
|
|
61
|
+
"@fluidframework/container-loader": "~2.53.0",
|
|
62
|
+
"@fluidframework/core-interfaces": "~2.53.0",
|
|
63
|
+
"@fluidframework/core-utils": "~2.53.0",
|
|
64
|
+
"@fluidframework/driver-definitions": "~2.53.0",
|
|
65
|
+
"@fluidframework/fluid-static": "~2.53.0",
|
|
66
|
+
"@fluidframework/map": "~2.53.0",
|
|
67
|
+
"@fluidframework/runtime-utils": "~2.53.0",
|
|
68
|
+
"@fluidframework/sequence": "~2.53.0",
|
|
69
|
+
"@fluidframework/shared-object-base": "~2.53.0",
|
|
70
|
+
"@fluidframework/tree": "~2.53.0"
|
|
71
71
|
},
|
|
72
72
|
"devDependencies": {
|
|
73
73
|
"@arethetypeswrong/cli": "^0.17.1",
|