@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/lib/core/schema-stored/index.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { TreeFieldStoredSchema, ValueSchema, TreeNodeStoredSchema, TreeTypeSet, FieldKindSpecifier, TreeStoredSchema, forbiddenFieldKindIdentifier, storedEmptyFieldSchema, StoredSchemaCollection, LeafNodeStoredSchema, ObjectNodeStoredSchema, MapNodeStoredSchema, BrandedTreeNodeSchemaDataFormat, decodeFieldSchema, encodeFieldSchema, storedSchemaDecodeDispatcher, ErasedTreeNodeSchemaDataFormat, } from "./schema";
+export { TreeStoredSchemaSubscription, MutableTreeStoredSchema, TreeStoredSchemaRepository, schemaDataIsEmpty, SchemaEvents, } from "./storedSchemaRepository";
+export { TreeNodeSchemaIdentifier, FieldKey, FieldKindIdentifier } from "./format";
+import * as schemaFormat from "./format";
+export { schemaFormat };
+//# sourceMappingURL=index.d.ts.map

package/lib/core/schema-stored/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/schema-stored/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,qBAAqB,EACrB,WAAW,EACX,oBAAoB,EACpB,WAAW,EACX,kBAAkB,EAClB,gBAAgB,EAChB,4BAA4B,EAC5B,sBAAsB,EACtB,sBAAsB,EACtB,oBAAoB,EACpB,sBAAsB,EACtB,mBAAmB,EACnB,+BAA+B,EAC/B,iBAAiB,EACjB,iBAAiB,EACjB,4BAA4B,EAC5B,8BAA8B,GAC9B,MAAM,UAAU,CAAC;AAClB,OAAO,EACN,4BAA4B,EAC5B,uBAAuB,EACvB,0BAA0B,EAC1B,iBAAiB,EACjB,YAAY,GACZ,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,wBAAwB,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEnF,OAAO,KAAK,YAAY,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/lib/core/schema-stored/index.js

@@ -0,0 +1,9 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { ValueSchema, TreeNodeStoredSchema, forbiddenFieldKindIdentifier, storedEmptyFieldSchema, LeafNodeStoredSchema, ObjectNodeStoredSchema, MapNodeStoredSchema, decodeFieldSchema, encodeFieldSchema, storedSchemaDecodeDispatcher, } from "./schema";
+export { TreeStoredSchemaRepository, schemaDataIsEmpty, } from "./storedSchemaRepository";
+import * as schemaFormat from "./format";
+export { schemaFormat };
+//# sourceMappingURL=index.js.map

package/lib/core/schema-stored/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/schema-stored/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAEN,WAAW,EACX,oBAAoB,EAIpB,4BAA4B,EAC5B,sBAAsB,EAEtB,oBAAoB,EACpB,sBAAsB,EACtB,mBAAmB,EAEnB,iBAAiB,EACjB,iBAAiB,EACjB,4BAA4B,GAE5B,MAAM,UAAU,CAAC;AAClB,OAAO,EAGN,0BAA0B,EAC1B,iBAAiB,GAEjB,MAAM,0BAA0B,CAAC;AAIlC,OAAO,KAAK,YAAY,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport {\n\tTreeFieldStoredSchema,\n\tValueSchema,\n\tTreeNodeStoredSchema,\n\tTreeTypeSet,\n\tFieldKindSpecifier,\n\tTreeStoredSchema,\n\tforbiddenFieldKindIdentifier,\n\tstoredEmptyFieldSchema,\n\tStoredSchemaCollection,\n\tLeafNodeStoredSchema,\n\tObjectNodeStoredSchema,\n\tMapNodeStoredSchema,\n\tBrandedTreeNodeSchemaDataFormat,\n\tdecodeFieldSchema,\n\tencodeFieldSchema,\n\tstoredSchemaDecodeDispatcher,\n\tErasedTreeNodeSchemaDataFormat,\n} from \"./schema\";\nexport {\n\tTreeStoredSchemaSubscription,\n\tMutableTreeStoredSchema,\n\tTreeStoredSchemaRepository,\n\tschemaDataIsEmpty,\n\tSchemaEvents,\n} from \"./storedSchemaRepository\";\n\nexport { TreeNodeSchemaIdentifier, FieldKey, FieldKindIdentifier } from \"./format\";\n\nimport * as schemaFormat from \"./format\";\nexport { schemaFormat };\n"]}

package/lib/core/schema-stored/schema.d.ts

@@ -0,0 +1,195 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { DiscriminatedUnionDispatcher } from "../../codec";
+import { Brand, Erased, MakeNominal } from "../../util";
+import { FieldKey, FieldKindIdentifier, FieldSchemaFormat, TreeNodeSchemaDataFormat, TreeNodeSchemaIdentifier } from "./format";
+/**
+ * Schema for what {@link TreeValue} is allowed on a Leaf node.
+ * @internal
+ */
+export declare enum ValueSchema {
+    Number = 0,
+    String = 1,
+    Boolean = 2,
+    FluidHandle = 3,
+    Null = 4
+}
+/**
+ * Set of allowed tree types.
+ * Providing multiple values here allows polymorphism, tagged union style.
+ *
+ * If not specified, types are unconstrained
+ * (equivalent to the set containing every TreeNodeSchemaIdentifier defined in the document).
+ *
+ * Note that even when unconstrained, children must still be in-schema for their own type.
+ *
+ * In the future, this could be extended to allow inlining a TreeNodeStoredSchema here
+ * (or some similar structural schema system).
+ * For structural types which could go here, there are a few interesting options:
+ *
+ * - Allow replacing the whole set with a structural type for terminal / non-tree data,
+ * and use this as a replacement for values on the tree nodes.
+ *
+ * - Allow expression structural constraints for child trees, for example requiring specific traits
+ * (ex: via TreeNodeStoredSchema), instead of by type.
+ *
+ * There are two ways this could work:
+ *
+ * - Constrain the child nodes based on their shape:
+ * this makes schema safe editing difficult because nodes would incur extra editing constraints to prevent them
+ * from going out of schema based on their location in such a field.
+ *
+ * - Constrain the types allowed based on which types guarantee their data will always meet the constraints.
+ *
+ * Care would need to be taken to make sure this is sound for the schema updating mechanisms.
+ * @internal
+ */
+export type TreeTypeSet = ReadonlySet<TreeNodeSchemaIdentifier> | undefined;
+/**
+ * Specifies which field kind to use.
+ *
+ * @remarks
+ * This is used instead of just the FieldKindIdentifier so that it can be subtyped into a more expressive type with additional information.
+ *
+ * @internal
+ */
+export interface FieldKindSpecifier<T = FieldKindIdentifier> {
+    identifier: T;
+}
+/**
+ * Schema for a field.
+ * Object implementing this interface should never be modified.
+ * @internal
+ */
+export interface TreeFieldStoredSchema {
+    readonly kind: FieldKindSpecifier;
+    /**
+     * The set of allowed child types.
+     * If not specified, types are unconstrained.
+     */
+    readonly types?: TreeTypeSet;
+}
+/**
+ * Identifier used for the FieldKind for fields which must be empty.
+ *
+ * @remarks
+ * This mainly show up in:
+ * 1. The root default field for documents.
+ * 2. The schema used for out of schema fields (which thus must be empty/not exist) on object and leaf nodes.
+ *
+ * @internal
+ */
+export declare const forbiddenFieldKindIdentifier = "Forbidden";
+/**
+ * A schema for empty fields (fields which must always be empty).
+ * There are multiple ways this could be encoded, but this is the most explicit.
+ */
+export declare const storedEmptyFieldSchema: TreeFieldStoredSchema;
+/**
+ * Opaque type erased handle to the encoded representation of the contents of a stored schema.
+ * @internal
+ */
+export interface ErasedTreeNodeSchemaDataFormat extends Erased<"TreeNodeSchemaDataFormat"> {
+}
+export interface BrandedTreeNodeSchemaDataFormat extends Brand<TreeNodeSchemaDataFormat, ErasedTreeNodeSchemaDataFormat> {
+}
+/**
+ * @internal
+ */
+export declare abstract class TreeNodeStoredSchema {
+    protected _typeCheck: MakeNominal;
+    /**
+     * @privateRemarks
+     * Returns TreeNodeSchemaDataFormat.
+     * This is uses an opaque type to avoid leaking these types out of the package,
+     * and is runtime validated by the codec.
+     */
+    abstract encode(): ErasedTreeNodeSchemaDataFormat;
+}
+/**
+ * @internal
+ */
+export declare class ObjectNodeStoredSchema extends TreeNodeStoredSchema {
+    readonly objectNodeFields: ReadonlyMap<FieldKey, TreeFieldStoredSchema>;
+    /**
+     * @param objectNodeFields -
+     * Schema for fields with keys scoped to this TreeNodeStoredSchema.
+     * This refers to the TreeFieldStoredSchema directly
+     * (as opposed to just supporting FieldSchemaIdentifier and having a central FieldKey -\> TreeFieldStoredSchema map).
+     * This allows os short friendly field keys which can ergonomically used as field names in code.
+     * It also interoperates well with mapFields being used as a map with arbitrary data as keys.
+     */
+    constructor(objectNodeFields: ReadonlyMap<FieldKey, TreeFieldStoredSchema>);
+    encode(): ErasedTreeNodeSchemaDataFormat;
+}
+/**
+ * @internal
+ */
+export declare class MapNodeStoredSchema extends TreeNodeStoredSchema {
+    readonly mapFields: TreeFieldStoredSchema;
+    /**
+     * @param mapFields -
+     * Allows using using the fields as a map, with the keys being
+     * FieldKeys and the values being constrained by this TreeFieldStoredSchema.
+     * Usually `FieldKind.Value` should NOT be used here
+     * since no nodes can ever be in schema are in schema if you use `FieldKind.Value` here
+     * (that would require infinite children).
+     */
+    constructor(mapFields: TreeFieldStoredSchema);
+    encode(): ErasedTreeNodeSchemaDataFormat;
+}
+/**
+ * @internal
+ */
+export declare class LeafNodeStoredSchema extends TreeNodeStoredSchema {
+    readonly leafValue: ValueSchema;
+    /**
+     * @param leafValue -
+     * There are several approaches for how to store actual data in the tree
+     * (special node types, special field contents, data on nodes etc.)
+     * as well as several options about how the data should be modeled at this level
+     * (byte sequence? javascript type? json?),
+     * as well as options for how much of this would be exposed in the schema language
+     * (ex: would all nodes with values be special built-ins, or could any schema add them?)
+     * A simple easy to do in javascript approach is taken here:
+     * this is not intended to be a suggestion of what approach to take, or what to expose in the schema language.
+     * This is simply one approach that can work for modeling them in the internal schema representation.
+     */
+    constructor(leafValue: ValueSchema);
+    encode(): ErasedTreeNodeSchemaDataFormat;
+}
+export declare const storedSchemaDecodeDispatcher: DiscriminatedUnionDispatcher<TreeNodeSchemaDataFormat, [
+], TreeNodeStoredSchema>;
+export declare function encodeFieldSchema(schema: TreeFieldStoredSchema): FieldSchemaFormat;
+export declare function decodeFieldSchema(schema: FieldSchemaFormat): TreeFieldStoredSchema;
+/**
+ * Document schema data that can be stored in a document.
+ *
+ * @remarks
+ * Note: the owner of this may modify it over time:
+ * thus if needing to hand onto a specific version, make a copy.
+ * @internal
+ */
+export interface TreeStoredSchema extends StoredSchemaCollection {
+    /**
+     * Schema for the root field which contains the whole tree.
+     */
+    readonly rootFieldSchema: TreeFieldStoredSchema;
+}
+/**
+ * Collection of TreeNodeSchema data that can be stored in a document.
+ *
+ * @remarks
+ * Note: the owner of this may modify it over time:
+ * thus if needing to hang onto a specific version, make a copy.
+ * @internal
+ */
+export interface StoredSchemaCollection {
+    /**
+     * {@inheritdoc StoredSchemaCollection}
+     */
+    readonly nodeSchema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>;
+}
+//# sourceMappingURL=schema.d.ts.map

package/lib/core/schema-stored/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/core/schema-stored/schema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EACN,KAAK,EACL,MAAM,EACN,WAAW,EAOX,MAAM,YAAY,CAAC;AACpB,OAAO,EACN,QAAQ,EACR,mBAAmB,EACnB,iBAAiB,EAGjB,wBAAwB,EACxB,wBAAwB,EACxB,MAAM,UAAU,CAAC;AAElB;;;GAGG;AACH,oBAAY,WAAW;IACtB,MAAM,IAAA;IACN,MAAM,IAAA;IACN,OAAO,IAAA;IACP,WAAW,IAAA;IACX,IAAI,IAAA;CACJ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,wBAAwB,CAAC,GAAG,SAAS,CAAC;AAE5E;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC,GAAG,mBAAmB;IAC1D,UAAU,EAAE,CAAC,CAAC;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACrC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;CAC7B;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,cAAc,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,qBAKpC,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,8BAA+B,SAAQ,MAAM,CAAC,0BAA0B,CAAC;CAAG;AAC7F,MAAM,WAAW,+BAChB,SAAQ,KAAK,CAAC,wBAAwB,EAAE,8BAA8B,CAAC;CAAG;AAE3E;;GAEG;AACH,8BAAsB,oBAAoB;IACzC,SAAS,CAAC,UAAU,EAAG,WAAW,CAAC;IAEnC;;;;;OAKG;aACa,MAAM,IAAI,8BAA8B;CACxD;AAED;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,oBAAoB;aAU9C,gBAAgB,EAAE,WAAW,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IAT/E;;;;;;;OAOG;gBAEc,gBAAgB,EAAE,WAAW,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IAK/D,MAAM,IAAI,8BAA8B;CASxD;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,oBAAoB;aASzB,SAAS,EAAE,qBAAqB;IARnE;;;;;;;OAOG;gBACgC,SAAS,EAAE,qBAAqB;IAInD,MAAM,IAAI,8BAA8B;CAKxD;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,oBAAoB;aAa1B,SAAS,EAAE,WAAW;IAZzD;;;;;;;;;;;OAWG;gBACgC,SAAS,EAAE,WAAW;IAIzC,MAAM,IAAI,8BAA8B;CAKxD;AAED,eAAO,MAAM,4BAA4B,EAAE,4BAA4B,CACtE,wBAAwB,EACxB;CAAE,EACF,oBAAoB,CAanB,CAAC;AAoBH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,qBAAqB,GAAG,iBAAiB,CAQlF;AASD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,qBAAqB,CAOlF;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAiB,SAAQ,sBAAsB;IAC/D;;OAEG;IACH,QAAQ,CAAC,eAAe,EAAE,qBAAqB,CAAC;CAChD;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB;IACtC;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,wBAAwB,EAAE,oBAAoB,CAAC,CAAC;CACjF"}

package/lib/core/schema-stored/schema.js

@@ -0,0 +1,165 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { DiscriminatedUnionDispatcher } from "../../codec";
+import { brand, brandErased, compareNamed, fail, invertMap, } from "../../util";
+import { PersistedValueSchema, } from "./format";
+/**
+ * Schema for what {@link TreeValue} is allowed on a Leaf node.
+ * @internal
+ */
+export var ValueSchema;
+(function (ValueSchema) {
+    ValueSchema[ValueSchema["Number"] = 0] = "Number";
+    ValueSchema[ValueSchema["String"] = 1] = "String";
+    ValueSchema[ValueSchema["Boolean"] = 2] = "Boolean";
+    ValueSchema[ValueSchema["FluidHandle"] = 3] = "FluidHandle";
+    ValueSchema[ValueSchema["Null"] = 4] = "Null";
+})(ValueSchema || (ValueSchema = {}));
+/**
+ * Identifier used for the FieldKind for fields which must be empty.
+ *
+ * @remarks
+ * This mainly show up in:
+ * 1. The root default field for documents.
+ * 2. The schema used for out of schema fields (which thus must be empty/not exist) on object and leaf nodes.
+ *
+ * @internal
+ */
+export const forbiddenFieldKindIdentifier = "Forbidden";
+/**
+ * A schema for empty fields (fields which must always be empty).
+ * There are multiple ways this could be encoded, but this is the most explicit.
+ */
+export const storedEmptyFieldSchema = {
+    // This kind requires the field to be empty.
+    kind: { identifier: brand(forbiddenFieldKindIdentifier) },
+    // This type set also forces the field to be empty not not allowing any types as all.
+    types: new Set(),
+};
+/**
+ * @internal
+ */
+export class TreeNodeStoredSchema {
+}
+/**
+ * @internal
+ */
+export class ObjectNodeStoredSchema extends TreeNodeStoredSchema {
+    /**
+     * @param objectNodeFields -
+     * Schema for fields with keys scoped to this TreeNodeStoredSchema.
+     * This refers to the TreeFieldStoredSchema directly
+     * (as opposed to just supporting FieldSchemaIdentifier and having a central FieldKey -\> TreeFieldStoredSchema map).
+     * This allows os short friendly field keys which can ergonomically used as field names in code.
+     * It also interoperates well with mapFields being used as a map with arbitrary data as keys.
+     */
+    constructor(objectNodeFields) {
+        super();
+        this.objectNodeFields = objectNodeFields;
+    }
+    encode() {
+        // Sort fields to ensure output is identical for for equivalent schema (since field order is not considered significant).
+        // This makes comparing schema easier, and ensures chunk reuse for schema summaries isn't needlessly broken.
+        return brandErased({
+            object: [...this.objectNodeFields]
+                .map(([k, v]) => encodeNamedField(k, v))
+                .sort(compareNamed),
+        });
+    }
+}
+/**
+ * @internal
+ */
+export class MapNodeStoredSchema extends TreeNodeStoredSchema {
+    /**
+     * @param mapFields -
+     * Allows using using the fields as a map, with the keys being
+     * FieldKeys and the values being constrained by this TreeFieldStoredSchema.
+     * Usually `FieldKind.Value` should NOT be used here
+     * since no nodes can ever be in schema are in schema if you use `FieldKind.Value` here
+     * (that would require infinite children).
+     */
+    constructor(mapFields) {
+        super();
+        this.mapFields = mapFields;
+    }
+    encode() {
+        return brandErased({
+            map: encodeFieldSchema(this.mapFields),
+        });
+    }
+}
+/**
+ * @internal
+ */
+export class LeafNodeStoredSchema extends TreeNodeStoredSchema {
+    /**
+     * @param leafValue -
+     * There are several approaches for how to store actual data in the tree
+     * (special node types, special field contents, data on nodes etc.)
+     * as well as several options about how the data should be modeled at this level
+     * (byte sequence? javascript type? json?),
+     * as well as options for how much of this would be exposed in the schema language
+     * (ex: would all nodes with values be special built-ins, or could any schema add them?)
+     * A simple easy to do in javascript approach is taken here:
+     * this is not intended to be a suggestion of what approach to take, or what to expose in the schema language.
+     * This is simply one approach that can work for modeling them in the internal schema representation.
+     */
+    constructor(leafValue) {
+        super();
+        this.leafValue = leafValue;
+    }
+    encode() {
+        return brandErased({
+            leaf: encodeValueSchema(this.leafValue),
+        });
+    }
+}
+export const storedSchemaDecodeDispatcher = new DiscriminatedUnionDispatcher({
+    leaf: (data) => new LeafNodeStoredSchema(decodeValueSchema(data)),
+    object: (data) => new ObjectNodeStoredSchema(new Map(data.map((field) => [
+        brand(field.name),
+        decodeFieldSchema(field),
+    ]))),
+    map: (data) => new MapNodeStoredSchema(decodeFieldSchema(data)),
+});
+const valueSchemaEncode = new Map([
+    [ValueSchema.Number, PersistedValueSchema.Number],
+    [ValueSchema.String, PersistedValueSchema.String],
+    [ValueSchema.Boolean, PersistedValueSchema.Boolean],
+    [ValueSchema.FluidHandle, PersistedValueSchema.FluidHandle],
+    [ValueSchema.Null, PersistedValueSchema.Null],
+]);
+const valueSchemaDecode = invertMap(valueSchemaEncode);
+function encodeValueSchema(inMemory) {
+    return valueSchemaEncode.get(inMemory) ?? fail("missing PersistedValueSchema");
+}
+function decodeValueSchema(inMemory) {
+    return valueSchemaDecode.get(inMemory) ?? fail("missing ValueSchema");
+}
+export function encodeFieldSchema(schema) {
+    const out = {
+        kind: schema.kind.identifier,
+    };
+    if (schema.types !== undefined) {
+        out.types = [...schema.types];
+    }
+    return out;
+}
+function encodeNamedField(name, schema) {
+    return {
+        ...encodeFieldSchema(schema),
+        name,
+    };
+}
+export function decodeFieldSchema(schema) {
+    const out = {
+        // TODO: maybe provide actual FieldKind objects here, error on unrecognized kinds.
+        kind: { identifier: schema.kind },
+        types: schema.types === undefined ? undefined : new Set(schema.types),
+    };
+    return out;
+}
+//# sourceMappingURL=schema.js.map

package/lib/core/schema-stored/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/core/schema-stored/schema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAKN,KAAK,EACL,WAAW,EACX,YAAY,EACZ,IAAI,EACJ,SAAS,GACT,MAAM,YAAY,CAAC;AACpB,OAAO,EAKN,oBAAoB,GAGpB,MAAM,UAAU,CAAC;AAElB;;;GAGG;AACH,MAAM,CAAN,IAAY,WAMX;AAND,WAAY,WAAW;IACtB,iDAAM,CAAA;IACN,iDAAM,CAAA;IACN,mDAAO,CAAA;IACP,2DAAW,CAAA;IACX,6CAAI,CAAA;AACL,CAAC,EANW,WAAW,KAAX,WAAW,QAMtB;AA4DD;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,WAAW,CAAC;AAExD;;;GAGG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAA0B;IAC5D,4CAA4C;IAC5C,IAAI,EAAE,EAAE,UAAU,EAAE,KAAK,CAAC,4BAA4B,CAAC,EAAE;IACzD,qFAAqF;IACrF,KAAK,EAAE,IAAI,GAAG,EAAE;CAChB,CAAC;AAUF;;GAEG;AACH,MAAM,OAAgB,oBAAoB;CAUzC;AAED;;GAEG;AACH,MAAM,OAAO,sBAAuB,SAAQ,oBAAoB;IAC/D;;;;;;;OAOG;IACH,YACiB,gBAA8D;QAE9E,KAAK,EAAE,CAAC;QAFQ,qBAAgB,GAAhB,gBAAgB,CAA8C;IAG/E,CAAC;IAEe,MAAM;QACrB,yHAAyH;QACzH,4GAA4G;QAC5G,OAAO,WAAW,CAAkC;YACnD,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC;iBAChC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;iBACvC,IAAI,CAAC,YAAY,CAAC;SACpB,CAAC,CAAC;IACJ,CAAC;CACD;AAED;;GAEG;AACH,MAAM,OAAO,mBAAoB,SAAQ,oBAAoB;IAC5D;;;;;;;OAOG;IACH,YAAmC,SAAgC;QAClE,KAAK,EAAE,CAAC;QAD0B,cAAS,GAAT,SAAS,CAAuB;IAEnE,CAAC;IAEe,MAAM;QACrB,OAAO,WAAW,CAAkC;YACnD,GAAG,EAAE,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC;SACtC,CAAC,CAAC;IACJ,CAAC;CACD;AAED;;GAEG;AACH,MAAM,OAAO,oBAAqB,SAAQ,oBAAoB;IAC7D;;;;;;;;;;;OAWG;IACH,YAAmC,SAAsB;QACxD,KAAK,EAAE,CAAC;QAD0B,cAAS,GAAT,SAAS,CAAa;IAEzD,CAAC;IAEe,MAAM;QACrB,OAAO,WAAW,CAAkC;YACnD,IAAI,EAAE,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC;SACvC,CAAC,CAAC;IACJ,CAAC;CACD;AAED,MAAM,CAAC,MAAM,4BAA4B,GAIrC,IAAI,4BAA4B,CAAC;IACpC,IAAI,EAAE,CAAC,IAA0B,EAAE,EAAE,CAAC,IAAI,oBAAoB,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IACvF,MAAM,EAAE,CAAC,IAA8B,EAAE,EAAE,CAC1C,IAAI,sBAAsB,CACzB,IAAI,GAAG,CACN,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,EAAqC,EAAE,CAAC;QACtD,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC;QACjB,iBAAiB,CAAC,KAAK,CAAC;KACxB,CAAC,CACF,CACD;IACF,GAAG,EAAE,CAAC,IAAuB,EAAE,EAAE,CAAC,IAAI,mBAAmB,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;CAClF,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC;IACjC,CAAC,WAAW,CAAC,MAAM,EAAE,oBAAoB,CAAC,MAAM,CAAC;IACjD,CAAC,WAAW,CAAC,MAAM,EAAE,oBAAoB,CAAC,MAAM,CAAC;IACjD,CAAC,WAAW,CAAC,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC;IACnD,CAAC,WAAW,CAAC,WAAW,EAAE,oBAAoB,CAAC,WAAW,CAAC;IAC3D,CAAC,WAAW,CAAC,IAAI,EAAE,oBAAoB,CAAC,IAAI,CAAC;CAC7C,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,CAAC,CAAC;AAEvD,SAAS,iBAAiB,CAAC,QAAqB;IAC/C,OAAO,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,8BAA8B,CAAC,CAAC;AAChF,CAAC;AAED,SAAS,iBAAiB,CAAC,QAA8B;IACxD,OAAO,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,qBAAqB,CAAC,CAAC;AACvE,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,MAA6B;IAC9D,MAAM,GAAG,GAAsB;QAC9B,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,UAAU;KAC5B,CAAC;IACF,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,EAAE;QAC/B,GAAG,CAAC,KAAK,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;KAC9B;IACD,OAAO,GAAG,CAAC;AACZ,CAAC;AAED,SAAS,gBAAgB,CAAI,IAAO,EAAE,MAA6B;IAClE,OAAO;QACN,GAAG,iBAAiB,CAAC,MAAM,CAAC;QAC5B,IAAI;KACJ,CAAC;AACH,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,MAAyB;IAC1D,MAAM,GAAG,GAA0B;QAClC,kFAAkF;QAClF,IAAI,EAAE,EAAE,UAAU,EAAE,MAAM,CAAC,IAAI,EAAE;QACjC,KAAK,EAAE,MAAM,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC;KACrE,CAAC;IACF,OAAO,GAAG,CAAC;AACZ,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { DiscriminatedUnionDispatcher } from \"../../codec\";\nimport {\n\tBrand,\n\tErased,\n\tMakeNominal,\n\tNamed,\n\tbrand,\n\tbrandErased,\n\tcompareNamed,\n\tfail,\n\tinvertMap,\n} from \"../../util\";\nimport {\n\tFieldKey,\n\tFieldKindIdentifier,\n\tFieldSchemaFormat,\n\tNamedFieldSchemaFormat,\n\tPersistedValueSchema,\n\tTreeNodeSchemaDataFormat,\n\tTreeNodeSchemaIdentifier,\n} from \"./format\";\n\n/**\n * Schema for what {@link TreeValue} is allowed on a Leaf node.\n * @internal\n */\nexport enum ValueSchema {\n\tNumber,\n\tString,\n\tBoolean,\n\tFluidHandle,\n\tNull,\n}\n\n/**\n * Set of allowed tree types.\n * Providing multiple values here allows polymorphism, tagged union style.\n *\n * If not specified, types are unconstrained\n * (equivalent to the set containing every TreeNodeSchemaIdentifier defined in the document).\n *\n * Note that even when unconstrained, children must still be in-schema for their own type.\n *\n * In the future, this could be extended to allow inlining a TreeNodeStoredSchema here\n * (or some similar structural schema system).\n * For structural types which could go here, there are a few interesting options:\n *\n * - Allow replacing the whole set with a structural type for terminal / non-tree data,\n * and use this as a replacement for values on the tree nodes.\n *\n * - Allow expression structural constraints for child trees, for example requiring specific traits\n * (ex: via TreeNodeStoredSchema), instead of by type.\n *\n * There are two ways this could work:\n *\n * - Constrain the child nodes based on their shape:\n * this makes schema safe editing difficult because nodes would incur extra editing constraints to prevent them\n * from going out of schema based on their location in such a field.\n *\n * - Constrain the types allowed based on which types guarantee their data will always meet the constraints.\n *\n * Care would need to be taken to make sure this is sound for the schema updating mechanisms.\n * @internal\n */\nexport type TreeTypeSet = ReadonlySet<TreeNodeSchemaIdentifier> | undefined;\n\n/**\n * Specifies which field kind to use.\n *\n * @remarks\n * This is used instead of just the FieldKindIdentifier so that it can be subtyped into a more expressive type with additional information.\n *\n * @internal\n */\nexport interface FieldKindSpecifier<T = FieldKindIdentifier> {\n\tidentifier: T;\n}\n\n/**\n * Schema for a field.\n * Object implementing this interface should never be modified.\n * @internal\n */\nexport interface TreeFieldStoredSchema {\n\treadonly kind: FieldKindSpecifier;\n\t/**\n\t * The set of allowed child types.\n\t * If not specified, types are unconstrained.\n\t */\n\treadonly types?: TreeTypeSet;\n}\n\n/**\n * Identifier used for the FieldKind for fields which must be empty.\n *\n * @remarks\n * This mainly show up in:\n * 1. The root default field for documents.\n * 2. The schema used for out of schema fields (which thus must be empty/not exist) on object and leaf nodes.\n *\n * @internal\n */\nexport const forbiddenFieldKindIdentifier = \"Forbidden\";\n\n/**\n * A schema for empty fields (fields which must always be empty).\n * There are multiple ways this could be encoded, but this is the most explicit.\n */\nexport const storedEmptyFieldSchema: TreeFieldStoredSchema = {\n\t// This kind requires the field to be empty.\n\tkind: { identifier: brand(forbiddenFieldKindIdentifier) },\n\t// This type set also forces the field to be empty not not allowing any types as all.\n\ttypes: new Set(),\n};\n\n/**\n * Opaque type erased handle to the encoded representation of the contents of a stored schema.\n * @internal\n */\nexport interface ErasedTreeNodeSchemaDataFormat extends Erased<\"TreeNodeSchemaDataFormat\"> {}\nexport interface BrandedTreeNodeSchemaDataFormat\n\textends Brand<TreeNodeSchemaDataFormat, ErasedTreeNodeSchemaDataFormat> {}\n\n/**\n * @internal\n */\nexport abstract class TreeNodeStoredSchema {\n\tprotected _typeCheck!: MakeNominal;\n\n\t/**\n\t * @privateRemarks\n\t * Returns TreeNodeSchemaDataFormat.\n\t * This is uses an opaque type to avoid leaking these types out of the package,\n\t * and is runtime validated by the codec.\n\t */\n\tpublic abstract encode(): ErasedTreeNodeSchemaDataFormat;\n}\n\n/**\n * @internal\n */\nexport class ObjectNodeStoredSchema extends TreeNodeStoredSchema {\n\t/**\n\t * @param objectNodeFields -\n\t * Schema for fields with keys scoped to this TreeNodeStoredSchema.\n\t * This refers to the TreeFieldStoredSchema directly\n\t * (as opposed to just supporting FieldSchemaIdentifier and having a central FieldKey -\\> TreeFieldStoredSchema map).\n\t * This allows os short friendly field keys which can ergonomically used as field names in code.\n\t * It also interoperates well with mapFields being used as a map with arbitrary data as keys.\n\t */\n\tpublic constructor(\n\t\tpublic readonly objectNodeFields: ReadonlyMap<FieldKey, TreeFieldStoredSchema>,\n\t) {\n\t\tsuper();\n\t}\n\n\tpublic override encode(): ErasedTreeNodeSchemaDataFormat {\n\t\t// Sort fields to ensure output is identical for for equivalent schema (since field order is not considered significant).\n\t\t// This makes comparing schema easier, and ensures chunk reuse for schema summaries isn't needlessly broken.\n\t\treturn brandErased<BrandedTreeNodeSchemaDataFormat>({\n\t\t\tobject: [...this.objectNodeFields]\n\t\t\t\t.map(([k, v]) => encodeNamedField(k, v))\n\t\t\t\t.sort(compareNamed),\n\t\t});\n\t}\n}\n\n/**\n * @internal\n */\nexport class MapNodeStoredSchema extends TreeNodeStoredSchema {\n\t/**\n\t * @param mapFields -\n\t * Allows using using the fields as a map, with the keys being\n\t * FieldKeys and the values being constrained by this TreeFieldStoredSchema.\n\t * Usually `FieldKind.Value` should NOT be used here\n\t * since no nodes can ever be in schema are in schema if you use `FieldKind.Value` here\n\t * (that would require infinite children).\n\t */\n\tpublic constructor(public readonly mapFields: TreeFieldStoredSchema) {\n\t\tsuper();\n\t}\n\n\tpublic override encode(): ErasedTreeNodeSchemaDataFormat {\n\t\treturn brandErased<BrandedTreeNodeSchemaDataFormat>({\n\t\t\tmap: encodeFieldSchema(this.mapFields),\n\t\t});\n\t}\n}\n\n/**\n * @internal\n */\nexport class LeafNodeStoredSchema extends TreeNodeStoredSchema {\n\t/**\n\t * @param leafValue -\n\t * There are several approaches for how to store actual data in the tree\n\t * (special node types, special field contents, data on nodes etc.)\n\t * as well as several options about how the data should be modeled at this level\n\t * (byte sequence? javascript type? json?),\n\t * as well as options for how much of this would be exposed in the schema language\n\t * (ex: would all nodes with values be special built-ins, or could any schema add them?)\n\t * A simple easy to do in javascript approach is taken here:\n\t * this is not intended to be a suggestion of what approach to take, or what to expose in the schema language.\n\t * This is simply one approach that can work for modeling them in the internal schema representation.\n\t */\n\tpublic constructor(public readonly leafValue: ValueSchema) {\n\t\tsuper();\n\t}\n\n\tpublic override encode(): ErasedTreeNodeSchemaDataFormat {\n\t\treturn brandErased<BrandedTreeNodeSchemaDataFormat>({\n\t\t\tleaf: encodeValueSchema(this.leafValue),\n\t\t});\n\t}\n}\n\nexport const storedSchemaDecodeDispatcher: DiscriminatedUnionDispatcher<\n\tTreeNodeSchemaDataFormat,\n\t[],\n\tTreeNodeStoredSchema\n> = new DiscriminatedUnionDispatcher({\n\tleaf: (data: PersistedValueSchema) => new LeafNodeStoredSchema(decodeValueSchema(data)),\n\tobject: (data: NamedFieldSchemaFormat[]) =>\n\t\tnew ObjectNodeStoredSchema(\n\t\t\tnew Map(\n\t\t\t\tdata.map((field): [FieldKey, TreeFieldStoredSchema] => [\n\t\t\t\t\tbrand(field.name),\n\t\t\t\t\tdecodeFieldSchema(field),\n\t\t\t\t]),\n\t\t\t),\n\t\t),\n\tmap: (data: FieldSchemaFormat) => new MapNodeStoredSchema(decodeFieldSchema(data)),\n});\n\nconst valueSchemaEncode = new Map([\n\t[ValueSchema.Number, PersistedValueSchema.Number],\n\t[ValueSchema.String, PersistedValueSchema.String],\n\t[ValueSchema.Boolean, PersistedValueSchema.Boolean],\n\t[ValueSchema.FluidHandle, PersistedValueSchema.FluidHandle],\n\t[ValueSchema.Null, PersistedValueSchema.Null],\n]);\n\nconst valueSchemaDecode = invertMap(valueSchemaEncode);\n\nfunction encodeValueSchema(inMemory: ValueSchema): PersistedValueSchema {\n\treturn valueSchemaEncode.get(inMemory) ?? fail(\"missing PersistedValueSchema\");\n}\n\nfunction decodeValueSchema(inMemory: PersistedValueSchema): ValueSchema {\n\treturn valueSchemaDecode.get(inMemory) ?? fail(\"missing ValueSchema\");\n}\n\nexport function encodeFieldSchema(schema: TreeFieldStoredSchema): FieldSchemaFormat {\n\tconst out: FieldSchemaFormat = {\n\t\tkind: schema.kind.identifier,\n\t};\n\tif (schema.types !== undefined) {\n\t\tout.types = [...schema.types];\n\t}\n\treturn out;\n}\n\nfunction encodeNamedField<T>(name: T, schema: TreeFieldStoredSchema): FieldSchemaFormat & Named<T> {\n\treturn {\n\t\t...encodeFieldSchema(schema),\n\t\tname,\n\t};\n}\n\nexport function decodeFieldSchema(schema: FieldSchemaFormat): TreeFieldStoredSchema {\n\tconst out: TreeFieldStoredSchema = {\n\t\t// TODO: maybe provide actual FieldKind objects here, error on unrecognized kinds.\n\t\tkind: { identifier: schema.kind },\n\t\ttypes: schema.types === undefined ? undefined : new Set(schema.types),\n\t};\n\treturn out;\n}\n\n/**\n * Document schema data that can be stored in a document.\n *\n * @remarks\n * Note: the owner of this may modify it over time:\n * thus if needing to hand onto a specific version, make a copy.\n * @internal\n */\nexport interface TreeStoredSchema extends StoredSchemaCollection {\n\t/**\n\t * Schema for the root field which contains the whole tree.\n\t */\n\treadonly rootFieldSchema: TreeFieldStoredSchema;\n}\n\n/**\n * Collection of TreeNodeSchema data that can be stored in a document.\n *\n * @remarks\n * Note: the owner of this may modify it over time:\n * thus if needing to hang onto a specific version, make a copy.\n * @internal\n */\nexport interface StoredSchemaCollection {\n\t/**\n\t * {@inheritdoc StoredSchemaCollection}\n\t */\n\treadonly nodeSchema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>;\n}\n"]}

package/lib/core/schema-stored/storedSchemaRepository.d.ts

@@ -0,0 +1,71 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import BTree from "sorted-btree";
+import { ISubscribable } from "../../events";
+import { TreeFieldStoredSchema, TreeNodeStoredSchema, TreeStoredSchema } from "./schema";
+import { TreeNodeSchemaIdentifier } from "./format";
+/**
+ * Events for {@link TreeStoredSchemaSubscription}.
+ *
+ * TODO: consider having before and after events per subtree instead while applying anchor (and this just shows what happens at the root).
+ * @internal
+ */
+export interface SchemaEvents {
+    /**
+     * Schema change is about to be applied.
+     */
+    beforeSchemaChange(newSchema: TreeStoredSchema): void;
+    /**
+     * Schema change was just applied.
+     */
+    afterSchemaChange(newSchema: TreeStoredSchema): void;
+}
+/**
+ * A collection of stored schema that fires events in response to changes.
+ * @internal
+ */
+export interface TreeStoredSchemaSubscription extends ISubscribable<SchemaEvents>, TreeStoredSchema {
+}
+/**
+ * Mutable collection of stored schema.
+ * @internal
+ */
+export interface MutableTreeStoredSchema extends TreeStoredSchemaSubscription {
+    /**
+     * Mutates the stored schema.
+     * Replaces all schema with the provided schema.
+     * Can over-write preexisting schema, and removes unmentioned schema.
+     */
+    apply(newSchema: TreeStoredSchema): void;
+}
+/**
+ * Mutable TreeStoredSchema repository.
+ */
+export declare class TreeStoredSchemaRepository implements MutableTreeStoredSchema {
+    protected nodeSchemaData: BTree<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>;
+    protected rootFieldSchemaData: TreeFieldStoredSchema;
+    protected readonly events: ISubscribable<SchemaEvents> & import("../../events").IEmitter<SchemaEvents> & import("../../events").HasListeners<SchemaEvents>;
+    /**
+     * Copies in the provided schema. If `data` is an TreeStoredSchemaRepository, it will be cheap-cloned.
+     * Otherwise, it will be deep-cloned.
+     *
+     * We might not want to store schema in maps long term, as we might want a way to reserve a
+     * large space of schema IDs within a schema.
+     * The way mapFields has been structured mitigates the need for this, but it still might be useful.
+     *
+     * (ex: someone using data as field identifiers might want to
+     * reserve all fields identifiers starting with "foo." to have a specific schema).
+     * Combined with support for such namespaces in the allowed sets in the schema objects,
+     * that might provide a decent alternative to mapFields (which is a bit odd).
+     */
+    constructor(data?: TreeStoredSchema);
+    on<K extends keyof SchemaEvents>(eventName: K, listener: SchemaEvents[K]): () => void;
+    get nodeSchema(): ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>;
+    get rootFieldSchema(): TreeFieldStoredSchema;
+    apply(newSchema: TreeStoredSchema): void;
+    clone(): TreeStoredSchemaRepository;
+}
+export declare function schemaDataIsEmpty(data: TreeStoredSchema): boolean;
+//# sourceMappingURL=storedSchemaRepository.d.ts.map

package/lib/core/schema-stored/storedSchemaRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storedSchemaRepository.d.ts","sourceRoot":"","sources":["../../../src/core/schema-stored/storedSchemaRepository.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,MAAM,cAAc,CAAC;AACjC,OAAO,EAAiB,aAAa,EAAE,MAAM,cAAc,CAAC;AAE5D,OAAO,EAEN,qBAAqB,EACrB,oBAAoB,EACpB,gBAAgB,EAEhB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC5B;;OAEG;IACH,kBAAkB,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAEtD;;OAEG;IACH,iBAAiB,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAAC;CACrD;AAED;;;GAGG;AACH,MAAM,WAAW,4BAChB,SAAQ,aAAa,CAAC,YAAY,CAAC,EAClC,gBAAgB;CAAG;AAErB;;;GAGG;AACH,MAAM,WAAW,uBAAwB,SAAQ,4BAA4B;IAC5E;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAAC;CACzC;AAED;;GAEG;AACH,qBAAa,0BAA2B,YAAW,uBAAuB;IACzE,SAAS,CAAC,cAAc,EAAE,KAAK,CAAC,wBAAwB,EAAE,oBAAoB,CAAC,CAAC;IAChF,SAAS,CAAC,mBAAmB,EAAE,qBAAqB,CAAC;IACrD,SAAS,CAAC,QAAQ,CAAC,MAAM,kIAAiC;IAE1D;;;;;;;;;;;;OAYG;gBACgB,IAAI,CAAC,EAAE,gBAAgB;IAkBnC,EAAE,CAAC,CAAC,SAAS,MAAM,YAAY,EAAE,SAAS,EAAE,CAAC,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAI5F,IAAW,UAAU,IAAI,WAAW,CAAC,wBAAwB,EAAE,oBAAoB,CAAC,CAMnF;IAED,IAAW,eAAe,IAAI,qBAAqB,CAElD;IAEM,KAAK,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI;IASxC,KAAK,IAAI,0BAA0B;CAG1C;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAEjE"}

package/lib/core/schema-stored/storedSchemaRepository.js

@@ -0,0 +1,73 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import BTree from "sorted-btree";
+import { createEmitter } from "../../events";
+import { compareStrings } from "../../util";
+import { storedEmptyFieldSchema, } from "./schema";
+/**
+ * Mutable TreeStoredSchema repository.
+ */
+export class TreeStoredSchemaRepository {
+    /**
+     * Copies in the provided schema. If `data` is an TreeStoredSchemaRepository, it will be cheap-cloned.
+     * Otherwise, it will be deep-cloned.
+     *
+     * We might not want to store schema in maps long term, as we might want a way to reserve a
+     * large space of schema IDs within a schema.
+     * The way mapFields has been structured mitigates the need for this, but it still might be useful.
+     *
+     * (ex: someone using data as field identifiers might want to
+     * reserve all fields identifiers starting with "foo." to have a specific schema).
+     * Combined with support for such namespaces in the allowed sets in the schema objects,
+     * that might provide a decent alternative to mapFields (which is a bit odd).
+     */
+    constructor(data) {
+        this.events = createEmitter();
+        if (data === undefined) {
+            this.rootFieldSchemaData = storedEmptyFieldSchema;
+            this.nodeSchemaData = new BTree([], compareStrings);
+        }
+        else {
+            if (data instanceof TreeStoredSchemaRepository) {
+                this.rootFieldSchemaData = data.rootFieldSchema;
+                this.nodeSchemaData = data.nodeSchemaData.clone();
+            }
+            else {
+                this.rootFieldSchemaData = data.rootFieldSchema;
+                this.nodeSchemaData = cloneNodeSchemaData(data.nodeSchema);
+            }
+        }
+    }
+    on(eventName, listener) {
+        return this.events.on(eventName, listener);
+    }
+    get nodeSchema() {
+        // Btree implements iterator, but not in a type-safe way
+        return this.nodeSchemaData;
+    }
+    get rootFieldSchema() {
+        return this.rootFieldSchemaData;
+    }
+    apply(newSchema) {
+        this.events.emit("beforeSchemaChange", newSchema);
+        const clone = new TreeStoredSchemaRepository(newSchema);
+        // In the future, we could use btree's delta functionality to do a more efficient update
+        this.rootFieldSchemaData = clone.rootFieldSchemaData;
+        this.nodeSchemaData = clone.nodeSchemaData;
+        this.events.emit("afterSchemaChange", newSchema);
+    }
+    clone() {
+        return new TreeStoredSchemaRepository(this);
+    }
+}
+export function schemaDataIsEmpty(data) {
+    return data.nodeSchema.size === 0;
+}
+function cloneNodeSchemaData(nodeSchema) {
+    // Schema objects are immutable (unlike stored schema repositories), so this shallow copy is fine.
+    const entries = [...nodeSchema.entries()];
+    return new BTree(entries, compareStrings);
+}
+//# sourceMappingURL=storedSchemaRepository.js.map

package/lib/core/schema-stored/storedSchemaRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storedSchemaRepository.js","sourceRoot":"","sources":["../../../src/core/schema-stored/storedSchemaRepository.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,MAAM,cAAc,CAAC;AACjC,OAAO,EAAE,aAAa,EAAiB,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAKN,sBAAsB,GACtB,MAAM,UAAU,CAAC;AA0ClB;;GAEG;AACH,MAAM,OAAO,0BAA0B;IAKtC;;;;;;;;;;;;OAYG;IACH,YAAmB,IAAuB;QAfvB,WAAM,GAAG,aAAa,EAAgB,CAAC;QAgBzD,IAAI,IAAI,KAAK,SAAS,EAAE;YACvB,IAAI,CAAC,mBAAmB,GAAG,sBAAsB,CAAC;YAClD,IAAI,CAAC,cAAc,GAAG,IAAI,KAAK,CAC9B,EAAE,EACF,cAAc,CACd,CAAC;SACF;aAAM;YACN,IAAI,IAAI,YAAY,0BAA0B,EAAE;gBAC/C,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,eAAe,CAAC;gBAChD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;aAClD;iBAAM;gBACN,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,eAAe,CAAC;gBAChD,IAAI,CAAC,cAAc,GAAG,mBAAmB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC3D;SACD;IACF,CAAC;IAEM,EAAE,CAA+B,SAAY,EAAE,QAAyB;QAC9E,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAC5C,CAAC;IAED,IAAW,UAAU;QACpB,wDAAwD;QACxD,OAAO,IAAI,CAAC,cAGX,CAAC;IACH,CAAC;IAED,IAAW,eAAe;QACzB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IACjC,CAAC;IAEM,KAAK,CAAC,SAA2B;QACvC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,CAAC;QAClD,MAAM,KAAK,GAAG,IAAI,0BAA0B,CAAC,SAAS,CAAC,CAAC;QACxD,wFAAwF;QACxF,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC,mBAAmB,CAAC;QACrD,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,cAAc,CAAC;QAC3C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,EAAE,SAAS,CAAC,CAAC;IAClD,CAAC;IAEM,KAAK;QACX,OAAO,IAAI,0BAA0B,CAAC,IAAI,CAAC,CAAC;IAC7C,CAAC;CACD;AAED,MAAM,UAAU,iBAAiB,CAAC,IAAsB;IACvD,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,KAAK,CAAC,CAAC;AACnC,CAAC;AAED,SAAS,mBAAmB,CAC3B,UAAgD;IAEhD,kGAAkG;IAClG,MAAM,OAAO,GAAuD,CAAC,GAAG,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC;IAC9F,OAAO,IAAI,KAAK,CAAiD,OAAO,EAAE,cAAc,CAAC,CAAC;AAC3F,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport BTree from \"sorted-btree\";\nimport { createEmitter, ISubscribable } from \"../../events\";\nimport { compareStrings } from \"../../util\";\nimport {\n\tStoredSchemaCollection,\n\tTreeFieldStoredSchema,\n\tTreeNodeStoredSchema,\n\tTreeStoredSchema,\n\tstoredEmptyFieldSchema,\n} from \"./schema\";\nimport { TreeNodeSchemaIdentifier } from \"./format\";\n\n/**\n * Events for {@link TreeStoredSchemaSubscription}.\n *\n * TODO: consider having before and after events per subtree instead while applying anchor (and this just shows what happens at the root).\n * @internal\n */\nexport interface SchemaEvents {\n\t/**\n\t * Schema change is about to be applied.\n\t */\n\tbeforeSchemaChange(newSchema: TreeStoredSchema): void;\n\n\t/**\n\t * Schema change was just applied.\n\t */\n\tafterSchemaChange(newSchema: TreeStoredSchema): void;\n}\n\n/**\n * A collection of stored schema that fires events in response to changes.\n * @internal\n */\nexport interface TreeStoredSchemaSubscription\n\textends ISubscribable<SchemaEvents>,\n\t\tTreeStoredSchema {}\n\n/**\n * Mutable collection of stored schema.\n * @internal\n */\nexport interface MutableTreeStoredSchema extends TreeStoredSchemaSubscription {\n\t/**\n\t * Mutates the stored schema.\n\t * Replaces all schema with the provided schema.\n\t * Can over-write preexisting schema, and removes unmentioned schema.\n\t */\n\tapply(newSchema: TreeStoredSchema): void;\n}\n\n/**\n * Mutable TreeStoredSchema repository.\n */\nexport class TreeStoredSchemaRepository implements MutableTreeStoredSchema {\n\tprotected nodeSchemaData: BTree<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>;\n\tprotected rootFieldSchemaData: TreeFieldStoredSchema;\n\tprotected readonly events = createEmitter<SchemaEvents>();\n\n\t/**\n\t * Copies in the provided schema. If `data` is an TreeStoredSchemaRepository, it will be cheap-cloned.\n\t * Otherwise, it will be deep-cloned.\n\t *\n\t * We might not want to store schema in maps long term, as we might want a way to reserve a\n\t * large space of schema IDs within a schema.\n\t * The way mapFields has been structured mitigates the need for this, but it still might be useful.\n\t *\n\t * (ex: someone using data as field identifiers might want to\n\t * reserve all fields identifiers starting with \"foo.\" to have a specific schema).\n\t * Combined with support for such namespaces in the allowed sets in the schema objects,\n\t * that might provide a decent alternative to mapFields (which is a bit odd).\n\t */\n\tpublic constructor(data?: TreeStoredSchema) {\n\t\tif (data === undefined) {\n\t\t\tthis.rootFieldSchemaData = storedEmptyFieldSchema;\n\t\t\tthis.nodeSchemaData = new BTree<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>(\n\t\t\t\t[],\n\t\t\t\tcompareStrings,\n\t\t\t);\n\t\t} else {\n\t\t\tif (data instanceof TreeStoredSchemaRepository) {\n\t\t\t\tthis.rootFieldSchemaData = data.rootFieldSchema;\n\t\t\t\tthis.nodeSchemaData = data.nodeSchemaData.clone();\n\t\t\t} else {\n\t\t\t\tthis.rootFieldSchemaData = data.rootFieldSchema;\n\t\t\t\tthis.nodeSchemaData = cloneNodeSchemaData(data.nodeSchema);\n\t\t\t}\n\t\t}\n\t}\n\n\tpublic on<K extends keyof SchemaEvents>(eventName: K, listener: SchemaEvents[K]): () => void {\n\t\treturn this.events.on(eventName, listener);\n\t}\n\n\tpublic get nodeSchema(): ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeStoredSchema> {\n\t\t// Btree implements iterator, but not in a type-safe way\n\t\treturn this.nodeSchemaData as unknown as ReadonlyMap<\n\t\t\tTreeNodeSchemaIdentifier,\n\t\t\tTreeNodeStoredSchema\n\t\t>;\n\t}\n\n\tpublic get rootFieldSchema(): TreeFieldStoredSchema {\n\t\treturn this.rootFieldSchemaData;\n\t}\n\n\tpublic apply(newSchema: TreeStoredSchema): void {\n\t\tthis.events.emit(\"beforeSchemaChange\", newSchema);\n\t\tconst clone = new TreeStoredSchemaRepository(newSchema);\n\t\t// In the future, we could use btree's delta functionality to do a more efficient update\n\t\tthis.rootFieldSchemaData = clone.rootFieldSchemaData;\n\t\tthis.nodeSchemaData = clone.nodeSchemaData;\n\t\tthis.events.emit(\"afterSchemaChange\", newSchema);\n\t}\n\n\tpublic clone(): TreeStoredSchemaRepository {\n\t\treturn new TreeStoredSchemaRepository(this);\n\t}\n}\n\nexport function schemaDataIsEmpty(data: TreeStoredSchema): boolean {\n\treturn data.nodeSchema.size === 0;\n}\n\nfunction cloneNodeSchemaData(\n\tnodeSchema: StoredSchemaCollection[\"nodeSchema\"],\n): BTree<TreeNodeSchemaIdentifier, TreeNodeStoredSchema> {\n\t// Schema objects are immutable (unlike stored schema repositories), so this shallow copy is fine.\n\tconst entries: [TreeNodeSchemaIdentifier, TreeNodeStoredSchema][] = [...nodeSchema.entries()];\n\treturn new BTree<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>(entries, compareStrings);\n}\n"]}

package/lib/core/schema-view/index.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { Adapters, Compatibility, TreeAdapter, AdaptedViewSchema, AllowedUpdateType } from "./view";
+//# sourceMappingURL=index.d.ts.map

package/lib/core/schema-view/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/schema-view/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,WAAW,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC"}

package/lib/core/schema-view/index.js

@@ -0,0 +1,6 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { Compatibility, AdaptedViewSchema, AllowedUpdateType } from "./view";
+//# sourceMappingURL=index.js.map

package/lib/core/schema-view/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/schema-view/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAY,aAAa,EAAe,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport { Adapters, Compatibility, TreeAdapter, AdaptedViewSchema, AllowedUpdateType } from \"./view\";\n"]}