@fluidframework/tree 2.50.0 → 2.51.0

package/src/simple-tree/unhydratedFlexTreeFromInsertable.ts

@@ -4,75 +4,23 @@
  */
 
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
-import { assert, fail, unreachableCase } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
-import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
+import { assert } from "@fluidframework/core-utils/internal";
 
-import {
-	EmptyKey,
-	type FieldKey,
-	type NodeData,
-	type TreeValue,
-	type ValueSchema,
-} from "../core/index.js";
-import { FieldKinds, isTreeValue, valueSchemaAllows } from "../feature-libraries/index.js";
-import { brand, isReadonlyArray, hasSingle } from "../util/index.js";
+import { hasSingle } from "../util/index.js";
 
-import { nullSchema } from "./leafNodeSchema.js";
-import {
-	type ImplicitAllowedTypes,
-	normalizeAllowedTypes,
-	isConstant,
-	type ImplicitFieldSchema,
-	normalizeFieldSchema,
-	FieldKind,
-	type TreeLeafValue,
-	extractFieldProvider,
-	type ContextualFieldProvider,
-	unannotateImplicitAllowedTypes,
-} from "./schemaTypes.js";
+import { type ImplicitFieldSchema, normalizeFieldSchema, FieldKind } from "./fieldSchema.js";
 import {
-	createField,
+	CompatibilityLevel,
 	getKernel,
+	getTreeNodeSchemaPrivateData,
 	isTreeNode,
-	NodeKind,
 	type TreeNode,
 	type TreeNodeSchema,
 	type Unhydrated,
-	type UnhydratedFlexTreeField,
 	UnhydratedFlexTreeNode,
-	UnhydratedSequenceField,
 } from "./core/index.js";
 import { getUnhydratedContext } from "./createContext.js";
-import { convertFieldKind } from "./toStoredSchema.js";
-
-// Required to prevent the introduction of new circular dependencies
-// TODO: Having the schema provide their own policy functions for compatibility which
-// `unhydratedFlexTreeFromInsertable` invokes instead of manually handling each kind would remove this bad
-// dependency, and reduce coupling.
-/* eslint-disable import/no-internal-modules */
-import { isArrayNodeSchema, type ArrayNodeSchema } from "./node-kinds/array/arrayNodeTypes.js";
-import { isMapNodeSchema, type MapNodeSchema } from "./node-kinds/map/mapNodeTypes.js";
-import {
-	isObjectNodeSchema,
-	type ObjectNodeSchemaPrivate,
-} from "./node-kinds/object/objectNodeTypes.js";
-import {
-	isRecordNodeSchema,
-	type RecordNodeSchema,
-} from "./node-kinds/record/recordNodeTypes.js";
-/* eslint-enable import/no-internal-modules */
-
-/**
- * Module notes:
- *
- * The flow of the below code is in terms of the structure of the input data. We then verify that the associated
- * schema is appropriate for that kind of data. This is fine while we have a 1:1 mapping of kind of input data to
- * the kind of schema we expect for it (e.g. an input that is an array always need to be associated with a sequence in
- * the schema). If/when we begin accepting kinds of input data that are ambiguous (e.g. accepting an input that is an
- * array of key/value tuples to instantiate a map) we may need to rethink the structure here to be based more on the
- * schema than on the input data.
- */
 
 /**
  * Transforms an input {@link TypedNode} tree to an {@link UnhydratedFlexTreeNode}.
@@ -125,7 +73,7 @@ export function unhydratedFlexTreeFromInsertable<TIn extends InsertableContent |
 /**
  * Copy content from `data` into a UnhydratedFlexTreeNode.
  */
-function unhydratedFlexTreeFromInsertableNode(
+export function unhydratedFlexTreeFromInsertableNode(
 	data: InsertableContent,
 	allowedTypes: ReadonlySet<TreeNodeSchema>,
 ): UnhydratedFlexTreeNode {
@@ -144,322 +92,12 @@ function unhydratedFlexTreeFromInsertableNode(
 	}
 
 	const schema = getType(data, allowedTypes);
-
-	let result: FlexContent;
-	switch (schema.kind) {
-		case NodeKind.Leaf:
-			result = leafToFlexContent(data, schema, allowedTypes);
-			break;
-		case NodeKind.Array:
-			assert(isArrayNodeSchema(schema), 0x922 /* Expected an array schema. */);
-			result = arrayToFlexContent(data, schema);
-			break;
-		case NodeKind.Map:
-			assert(isMapNodeSchema(schema), 0x923 /* Expected a Map schema. */);
-			result = mapToFlexContent(data, schema);
-			break;
-		case NodeKind.Object:
-			assert(isObjectNodeSchema(schema), 0x924 /* Expected an Object schema. */);
-			result = objectToFlexContent(data, schema);
-			break;
-		case NodeKind.Record:
-			assert(isRecordNodeSchema(schema), 0xbdd /* Expected a Record schema. */);
-			result = recordToFlexContent(data, schema);
-			break;
-		default:
-			unreachableCase(schema.kind);
-	}
+	const handler = getTreeNodeSchemaPrivateData(schema).idempotentInitialize();
+	const result = handler.toFlexContent(data, allowedTypes);
 
 	return new UnhydratedFlexTreeNode(...result, getUnhydratedContext(schema));
 }
 
-type FlexContent = [NodeData, Map<FieldKey, UnhydratedFlexTreeField>];
-
-/**
- * Transforms data under a Leaf schema.
- * @param data - The tree data to be transformed. Must be a {@link TreeValue}.
- * @param schema - The schema associated with the value.
- * @param allowedTypes - The allowed types specified by the parent.
- * Used to determine which fallback values may be appropriate.
- */
-function leafToFlexContent(
-	data: FactoryContent,
-	schema: TreeNodeSchema,
-	allowedTypes: ReadonlySet<TreeNodeSchema>,
-): FlexContent {
-	assert(schema.kind === NodeKind.Leaf, 0x921 /* Expected a leaf schema. */);
-	if (!isTreeValue(data)) {
-		// This rule exists to protect against useless `toString` output like `[object Object]`.
-		// In this case, that's actually reasonable behavior, since object input is not compatible with Leaf schemas.
-		// eslint-disable-next-line @typescript-eslint/no-base-to-string
-		throw new UsageError(`Input data is incompatible with leaf schema: ${data}`);
-	}
-
-	const mappedValue = mapValueWithFallbacks(data, allowedTypes);
-	const mappedSchema = getType(mappedValue, allowedTypes);
-
-	assert(
-		allowsValue(mappedSchema, mappedValue),
-		0x84a /* Unsupported schema for provided primitive. */,
-	);
-
-	return [
-		{
-			value: mappedValue,
-			type: brand(mappedSchema.identifier),
-		},
-		new Map<FieldKey, UnhydratedFlexTreeField>(),
-	];
-}
-
-/**
- * Checks an incoming {@link TreeLeafValue} to ensure it is compatible with its requirements.
- * For unsupported values with a schema-compatible replacement, return the replacement value.
- * For unsupported values without a schema-compatible replacement, throw.
- * For supported values, return the input.
- */
-function mapValueWithFallbacks(
-	value: TreeLeafValue,
-	allowedTypes: ReadonlySet<TreeNodeSchema>,
-): TreeValue {
-	switch (typeof value) {
-		case "number": {
-			if (Object.is(value, -0)) {
-				// Our serialized data format does not support -0.
-				// Map such input to +0.
-				return 0;
-			} else if (!Number.isFinite(value)) {
-				// Our serialized data format does not support NaN nor +/-∞.
-				// If the schema supports `null`, fall back to that. Otherwise, throw.
-				// This is intended to match JSON's behavior for such values.
-				if (allowedTypes.has(nullSchema)) {
-					return null;
-				} else {
-					throw new UsageError(`Received unsupported numeric value: ${value}.`);
-				}
-			} else {
-				return value;
-			}
-		}
-		case "string":
-		// TODO:
-		// This should detect invalid strings. Something like @stdlib/regexp-utf16-unpaired-surrogate could be used to do this.
-		// See SchemaFactory.string for details.
-		case "boolean":
-			return value;
-		case "object": {
-			if (value === null || isFluidHandle(value)) {
-				return value;
-			}
-		}
-		default:
-			throw new UsageError(`Received unsupported leaf value: ${value}.`);
-	}
-}
-
-/**
- * Transforms data under an Array schema.
- * @param data - The tree data to be transformed.
- * @param allowedTypes - The set of types allowed by the parent context. Used to validate the input tree.
- */
-function arrayChildToFlexTree(
-	child: InsertableContent,
-	allowedTypes: ReadonlySet<TreeNodeSchema>,
-): UnhydratedFlexTreeNode {
-	// We do not support undefined sequence entries.
-	// If we encounter an undefined entry, use null instead if supported by the schema, otherwise throw.
-	let childWithFallback = child;
-	if (child === undefined) {
-		if (allowedTypes.has(nullSchema)) {
-			childWithFallback = null;
-		} else {
-			throw new TypeError(`Received unsupported array entry value: ${child}.`);
-		}
-	}
-	return unhydratedFlexTreeFromInsertableNode(childWithFallback, allowedTypes);
-}
-
-/**
- * Transforms data under an Array schema.
- * @param data - The tree data to be transformed. Must be an iterable.
- * @param schema - The schema associated with the value.
- */
-function arrayToFlexContent(data: FactoryContent, schema: ArrayNodeSchema): FlexContent {
-	if (!(typeof data === "object" && data !== null && Symbol.iterator in data)) {
-		throw new UsageError(`Input data is incompatible with Array schema: ${data}`);
-	}
-
-	const allowedChildTypes = normalizeAllowedTypes(schema.info as ImplicitAllowedTypes);
-
-	const mappedData = Array.from(data, (child) =>
-		arrayChildToFlexTree(child, allowedChildTypes),
-	);
-
-	const context = getUnhydratedContext(schema).flexContext;
-
-	// Array nodes have a single `EmptyKey` field:
-	const fieldsEntries =
-		mappedData.length === 0
-			? []
-			: ([
-					[
-						EmptyKey,
-						new UnhydratedSequenceField(
-							context,
-							FieldKinds.sequence.identifier,
-							EmptyKey,
-							mappedData,
-						),
-					],
-				] as const);
-
-	return [
-		{
-			type: brand(schema.identifier),
-		},
-		new Map(fieldsEntries),
-	];
-}
-
-/**
- * Transforms data under a Map schema.
- * @param data - The tree data to be transformed. Must be an iterable.
- * @param schema - The schema associated with the value.
- */
-function mapToFlexContent(data: FactoryContent, schema: MapNodeSchema): FlexContent {
-	if (!(typeof data === "object" && data !== null)) {
-		throw new UsageError(`Input data is incompatible with Map schema: ${data}`);
-	}
-
-	const fieldsIterator = (
-		Symbol.iterator in data
-			? // Support iterables of key value pairs (including Map objects)
-				data
-			: // Support record objects for JSON style Map data
-				Object.entries(data)
-	) as Iterable<readonly [string, InsertableContent]>;
-
-	return recordLikeDataToFlexContent(fieldsIterator, schema);
-}
-
-/**
- * Transforms data under an Object schema.
- * @param data - The tree data to be transformed. Must be a Record-like object.
- * @param schema - The schema associated with the value.
- */
-function objectToFlexContent(
-	data: FactoryContent,
-	schema: ObjectNodeSchemaPrivate,
-): FlexContent {
-	if (
-		typeof data !== "object" ||
-		data === null ||
-		Symbol.iterator in data ||
-		isFluidHandle(data)
-	) {
-		throw new UsageError(`Input data is incompatible with Object schema: ${data}`);
-	}
-
-	const fields = new Map<FieldKey, UnhydratedFlexTreeField>();
-	const context = getUnhydratedContext(schema).flexContext;
-
-	for (const [key, fieldInfo] of schema.flexKeyMap) {
-		const value = getFieldProperty(data, key);
-
-		let children: UnhydratedFlexTreeNode[] | ContextualFieldProvider;
-		if (value === undefined) {
-			const defaultProvider =
-				fieldInfo.schema.props?.defaultProvider ??
-				fail(0xbb1 /* missing field has no default provider */);
-			const fieldProvider = extractFieldProvider(defaultProvider);
-			children = isConstant(fieldProvider) ? fieldProvider() : fieldProvider;
-		} else {
-			children = [
-				unhydratedFlexTreeFromInsertableNode(value, fieldInfo.schema.allowedTypeSet),
-			];
-		}
-
-		const kind =
-			convertFieldKind.get(fieldInfo.schema.kind) ?? fail(0xbb2 /* Invalid field kind */);
-		fields.set(
-			fieldInfo.storedKey,
-			createField(context, kind.identifier, fieldInfo.storedKey, children),
-		);
-	}
-
-	return [{ type: brand(schema.identifier) }, fields];
-}
-
-/**
- * Transforms data under an Object schema.
- * @param data - The tree data to be transformed. Must be a Record-like object.
- * @param schema - The schema associated with the value.
- */
-function recordToFlexContent(data: FactoryContent, schema: RecordNodeSchema): FlexContent {
-	if (!(typeof data === "object" && data !== null)) {
-		throw new UsageError(`Input data is incompatible with Record schema: ${data}`);
-	}
-
-	const fieldsIterator: Iterable<readonly [string, InsertableContent]> = Object.entries(data);
-	return recordLikeDataToFlexContent(fieldsIterator, schema);
-}
-
-/**
- * Converts record-like data to a FlexContent representation for map/record schema.
- */
-function recordLikeDataToFlexContent(
-	fieldsIterator: Iterable<readonly [string, InsertableContent]>,
-	schema: MapNodeSchema | RecordNodeSchema,
-): FlexContent {
-	const allowedChildTypes = normalizeAllowedTypes(unannotateImplicitAllowedTypes(schema.info));
-	const context = getUnhydratedContext(schema).flexContext;
-
-	const transformedFields = new Map<FieldKey, UnhydratedFlexTreeField>();
-	for (const item of fieldsIterator) {
-		const [key, value] = item;
-		assert(!transformedFields.has(brand(key)), 0x84c /* Keys should not be duplicated */);
-
-		// Omit undefined values - an entry with an undefined value is equivalent to one that has been removed or omitted
-		if (value !== undefined) {
-			const child = unhydratedFlexTreeFromInsertableNode(value, allowedChildTypes);
-			const field = createField(context, FieldKinds.optional.identifier, brand(key), [child]);
-			transformedFields.set(brand(key), field);
-		}
-	}
-
-	return [
-		{
-			type: brand(schema.identifier),
-		},
-		transformedFields,
-	];
-}
-
-/**
- * Check {@link FactoryContentObject} for a property which could be store a field.
- *
- * @returns If the property exists, return its value. Otherwise, returns undefined.
- * @remarks
- * The currently policy is to only consider own properties.
- * See {@link InsertableObjectFromSchemaRecord} for where this policy is documented in the public API.
- *
- * Explicit undefined values are treated the same as missing properties to allow explicit use of undefined with defaulted identifiers.
- *
- * @privateRemarks
- * If we ever want to have an optional field which defaults to something other than undefined, this will need changes.
- * It would need to adjusting the handling of explicit undefined in contexts where undefined is allowed, and a default provider also exists.
- */
-function getFieldProperty(
-	data: FactoryContentObject,
-	key: string | symbol,
-): InsertableContent | undefined {
-	// This policy only allows own properties.
-	if (Object.hasOwnProperty.call(data, key)) {
-		return (data as Record<string, InsertableContent>)[key as string];
-	}
-	return undefined;
-}
-
 function getType(
 	data: FactoryContent,
 	allowedTypes: ReadonlySet<TreeNodeSchema>,
@@ -492,10 +130,13 @@ export function getPossibleTypes(
 	allowedTypes: ReadonlySet<TreeNodeSchema>,
 	data: FactoryContent,
 ): TreeNodeSchema[] {
+	assert(data !== undefined, 0x889 /* undefined cannot be used as FactoryContent. */);
+
 	let best = CompatibilityLevel.None;
 	const possibleTypes: TreeNodeSchema[] = [];
 	for (const schema of allowedTypes) {
-		const level = shallowCompatibilityTest(schema, data);
+		const handler = getTreeNodeSchemaPrivateData(schema).idempotentInitialize();
+		const level = handler.shallowCompatibilityTest(data);
 		if (level > best) {
 			possibleTypes.length = 0;
 			best = level;
@@ -507,129 +148,6 @@ export function getPossibleTypes(
 	return best === CompatibilityLevel.None ? [] : possibleTypes;
 }
 
-/**
- * Indicates a compatibility level for inferring a schema to apply to insertable data.
- * @remarks
- * Only the highest compatibility options are used.
- * This approach allows adding new possible matching at a new lower compatibility level as a non breaking change,
- * since that way they can't make a case that was compatible before ambiguous now.
- */
-enum CompatibilityLevel {
-	/**
-	 * Not compatible. Constructor typing indicates incompatibility.
-	 */
-	None = 0,
-	/**
-	 * Additional compatibility cases added in Fluid Framework 2.2.
-	 */
-	Low = 1,
-	/**
-	 * Compatible in Fluid Framework 2.0.
-	 */
-	Normal = 2,
-}
-
-/**
- * Checks if data might be schema-compatible.
- *
- * @returns false if `data` is incompatible with `type` based on a cheap/shallow check.
- *
- * Note that this may return true for cases where data is incompatible, but it must not return false in cases where the data is compatible.
- */
-function shallowCompatibilityTest(
-	schema: TreeNodeSchema,
-	data: FactoryContent,
-): CompatibilityLevel {
-	assert(data !== undefined, 0x889 /* undefined cannot be used as FactoryContent. */);
-
-	if (isTreeValue(data)) {
-		return allowsValue(schema, data) ? CompatibilityLevel.Normal : CompatibilityLevel.None;
-	}
-	if (schema.kind === NodeKind.Leaf) {
-		return CompatibilityLevel.None;
-	}
-
-	// Typing (of schema based constructors and thus implicit node construction)
-	// allows iterables for constructing maps and arrays.
-	// Some users of this API may have unions of maps and arrays,
-	// and rely on Arrays ending up as array nodes and maps as Map nodes,
-	// despite both being iterable and thus compatible with both.
-	// This uses a priority based system where an array would be parsed as an array when unioned with a map,
-	// but if in a map only context, could still be used as a map.
-
-	if (data instanceof Map) {
-		switch (schema.kind) {
-			case NodeKind.Map:
-				return CompatibilityLevel.Normal;
-			case NodeKind.Array:
-				// Maps are iterable, so type checking does allow constructing an ArrayNode from a map if the array's type is an array that includes the key and value types of the map.
-				return CompatibilityLevel.Low;
-			default:
-				return CompatibilityLevel.None;
-		}
-	}
-
-	if (isReadonlyArray(data)) {
-		switch (schema.kind) {
-			case NodeKind.Array:
-				return CompatibilityLevel.Normal;
-			case NodeKind.Map:
-				// Arrays are iterable, so type checking does allow constructing an array from a MapNode from an if the array's type is key values pairs for the map.
-				return CompatibilityLevel.Low;
-			default:
-				return CompatibilityLevel.None;
-		}
-	}
-
-	const mapOrArray = schema.kind === NodeKind.Array || schema.kind === NodeKind.Map;
-
-	if (Symbol.iterator in data) {
-		return mapOrArray ? CompatibilityLevel.Normal : CompatibilityLevel.None;
-	}
-
-	// At this point, it is assumed data is a record-like object since all the other cases have been eliminated.
-
-	if (schema.kind === NodeKind.Record) {
-		return CompatibilityLevel.Normal;
-	}
-
-	if (schema.kind === NodeKind.Array) {
-		return CompatibilityLevel.None;
-	}
-
-	if (schema.kind === NodeKind.Map) {
-		// When not unioned with an ObjectNode, allow objects to be used to create maps.
-		return CompatibilityLevel.Low;
-	}
-
-	assert(isObjectNodeSchema(schema), 0x9e6 /* unexpected schema kind */);
-
-	// TODO: Improve type inference by making this logic more thorough. Handle at least:
-	// * Types which are strict subsets of other types in the same polymorphic union
-	// * Types which have the same keys but different types for those keys in the polymorphic union
-	// * Types which have the same required fields but different optional fields and enough of those optional fields are populated to disambiguate
-
-	// TODO#7441: Consider allowing data to be inserted which has keys that are extraneous/unknown to the schema (those keys are ignored)
-
-	// If the schema has a required key which is not present in the input object, reject it.
-	for (const [fieldKey, fieldSchema] of schema.fields) {
-		if (fieldSchema.requiresValue) {
-			if (getFieldProperty(data, fieldKey) === undefined) {
-				return CompatibilityLevel.None;
-			}
-		}
-	}
-
-	return CompatibilityLevel.Normal;
-}
-
-function allowsValue(schema: TreeNodeSchema, value: TreeValue): boolean {
-	if (schema.kind === NodeKind.Leaf) {
-		return valueSchemaAllows(schema.info as ValueSchema, value);
-	}
-	return false;
-}
-
 /**
  * Content which can be used to build a node.
  * @remarks

package/src/simple-tree/unsafeUnknownSchema.ts

@@ -0,0 +1,70 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type {
+	ImplicitAllowedTypes,
+	InsertableTreeNodeFromImplicitAllowedTypes,
+} from "./core/index.js";
+import type {
+	ImplicitFieldSchema,
+	InsertableTreeFieldFromImplicitField,
+} from "./fieldSchema.js";
+import type { InsertableContent } from "./unhydratedFlexTreeFromInsertable.js";
+
+/**
+ * {@inheritdoc (UnsafeUnknownSchema:type)}
+ * @alpha
+ */
+
+export const UnsafeUnknownSchema: unique symbol = Symbol("UnsafeUnknownSchema");
+/**
+ * A special type which can be provided to some APIs as the schema type parameter when schema cannot easily be provided at compile time and an unsafe (instead of disabled) editing API is desired.
+ * @remarks
+ * When used, this means the TypeScript typing should err on the side of completeness (allow all inputs that could be valid).
+ * This introduces the risk that out-of-schema data could be allowed at compile time, and only error at runtime.
+ *
+ * @privateRemarks
+ * This only applies to APIs which input data which is expected to be in schema, since APIs outputting have easy mechanisms to do so in a type safe way even when the schema is unknown.
+ * In most cases that amounts to returning `TreeNode | TreeLeafValue`.
+ *
+ * This can be contrasted with the default behavior of TypeScript, which is to require the intersection of the possible types for input APIs,
+ * which for unknown schema defining input trees results in the `never` type.
+ *
+ * Any APIs which use this must produce UsageErrors when out of schema data is encountered, and never produce unrecoverable errors,
+ * or silently accept invalid data.
+ * This is currently only type exported from the package: the symbol is just used as a way to get a named type.
+ * @alpha
+ */
+
+export type UnsafeUnknownSchema = typeof UnsafeUnknownSchema;
+/**
+ * Content which could be inserted into a tree.
+ *
+ * @see {@link Input}
+ * @remarks
+ * Extended version of {@link InsertableTreeNodeFromImplicitAllowedTypes} that also allows {@link (UnsafeUnknownSchema:type)}.
+ * @alpha
+ */
+
+export type Insertable<TSchema extends ImplicitAllowedTypes | UnsafeUnknownSchema> =
+	TSchema extends ImplicitAllowedTypes
+		? InsertableTreeNodeFromImplicitAllowedTypes<TSchema>
+		: InsertableContent;
+
+/**
+ * Content which could be inserted into a field within a tree.
+ *
+ * @see {@link Input}
+ * @remarks
+ * Extended version of {@link InsertableTreeFieldFromImplicitField} that also allows {@link (UnsafeUnknownSchema:type)}.
+ * @alpha
+ */
+export type InsertableField<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> = [
+	TSchema,
+] extends [ImplicitFieldSchema]
+	? InsertableTreeFieldFromImplicitField<TSchema>
+	: [TSchema] extends [UnsafeUnknownSchema]
+		? InsertableContent | undefined
+		: never;

package/src/simple-tree/walkFieldSchema.ts

@@ -4,7 +4,7 @@
  */
 
 import { type TreeNodeSchema, walkAllowedTypes, type SchemaVisitor } from "./core/index.js";
-import { type ImplicitFieldSchema, normalizeFieldSchema } from "./schemaTypes.js";
+import { type ImplicitFieldSchema, normalizeFieldSchema } from "./fieldSchema.js";
 
 /**
  * Traverses all {@link TreeNodeSchema} schema reachable from `schema`, applying the visitor pattern.

package/src/treeFactory.ts

@@ -100,7 +100,6 @@ export const SharedTree = configuredSharedTree({});
  * 	TreeCompressionStrategy,
  * 	configuredSharedTree,
  * 	typeboxValidator,
- * 	// eslint-disable-next-line import/no-internal-modules
  * } from "@fluidframework/tree/internal";
  * const SharedTree = configuredSharedTree({
  * 	forest: ForestTypeReference,

package/dist/feature-libraries/modular-schema/discrepancies.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"discrepancies.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/modular-schema/discrepancies.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EACN,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAMxB,KAAK,wBAAwB,EAE7B,KAAK,gBAAgB,EAErB,KAAK,WAAW,EAChB,MAAM,qBAAqB,CAAC;AAO7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,eAAe,CAAC;AAE7D,MAAM,MAAM,eAAe,GAAG,mBAAmB,GAAG,qBAAqB,CAAC;AAE1E;;GAEG;AACH,MAAM,MAAM,gBAAgB,GACzB,sBAAsB,GACtB,oBAAoB,GACpB,sBAAsB,CAAC;AAE1B;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;;OAIG;IACH,UAAU,EAAE,wBAAwB,GAAG,SAAS,CAAC;IACjD;;;;;OAKG;IACH,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC/B;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAuB,SAAQ,wBAAwB;IACvE,QAAQ,EAAE,cAAc,CAAC;IACzB;;OAEG;IACH,IAAI,EAAE,wBAAwB,EAAE,CAAC;IACjC;;OAEG;IACH,MAAM,EAAE,wBAAwB,EAAE,CAAC;CACnC;AAED,MAAM,WAAW,oBAAqB,SAAQ,wBAAwB;IACrE,QAAQ,EAAE,WAAW,CAAC;IACtB,IAAI,EAAE,mBAAmB,CAAC;IAC1B,MAAM,EAAE,mBAAmB,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACtC,UAAU,EAAE,wBAAwB,CAAC;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,WAAW,GAAG,SAAS,CAAC;IAC9B,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;CAChC;AAED,MAAM,WAAW,mBAAmB;IACnC,UAAU,EAAE,wBAAwB,CAAC;IACrC,QAAQ,EAAE,UAAU,CAAC;IACrB,IAAI,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACxC,MAAM,EAAE,qBAAqB,GAAG,SAAS,CAAC;CAC1C;AAED,MAAM,WAAW,qBAAqB;IACrC,UAAU,EAAE,wBAAwB,CAAC;IACrC,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,gBAAgB,EAAE,CAAC;CAChC;AAED,KAAK,qBAAqB,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAavD;;;;;;;;;;GAUG;AACH,wBAAiB,8BAA8B,CAC9C,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,gBAAgB,GACtB,QAAQ,CAAC,WAAW,CAAC,CAuCvB;AAyLD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAkCxF;AAqBD;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAEhD;;;GAGG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC;AAgB/C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,mBAAmB,CAegC,CAAC;AAEzF,eAAO,MAAM,qBAAqB;;;;;CAKxB,CAAC;AACX,KAAK,qBAAqB,GACzB,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC;AAEpE,wBAAgB,oBAAoB,CAAC,CAAC,EACrC,CAAC,EAAE,CAAC,EACJ,CAAC,EAAE,CAAC,EACJ,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GACnB,qBAAqB,CAqBvB;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,OAAO,CAKtE"}