@fluidframework/tree 2.42.0 → 2.43.0-343119

package/src/simple-tree/node-kinds/array/arrayNode.ts

@@ -54,6 +54,7 @@ import type {
 	ArrayNodeCustomizableSchema,
 	ArrayNodePojoEmulationSchema,
 } from "./arrayNodeTypes.js";
+import type { JsonCompatibleReadOnlyObject } from "../../../util/index.js";
 
 /**
  * A covariant base type for {@link (TreeArrayNode:interface)}.
@@ -1082,6 +1083,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
  * Define a {@link TreeNodeSchema} for a {@link (TreeArrayNode:interface)}.
  *
  * @param name - Unique identifier for this schema including the factory's scope.
+ * @param persistedMetadata - Optional persisted metadata for the object node schema.
  */
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function arraySchema<
@@ -1095,6 +1097,7 @@ export function arraySchema<
 	implicitlyConstructable: ImplicitlyConstructable,
 	customizable: boolean,
 	metadata?: NodeSchemaMetadata<TCustomMetadata>,
+	persistedMetadata?: JsonCompatibleReadOnlyObject | undefined,
 ) {
 	type Output = ArrayNodeCustomizableSchema<
 		TName,
@@ -1190,6 +1193,8 @@ export function arraySchema<
 			return lazyChildTypes.value;
 		}
 		public static readonly metadata: NodeSchemaMetadata<TCustomMetadata> = metadata ?? {};
+		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
+			persistedMetadata;
 
 		// eslint-disable-next-line import/no-deprecated
 		public get [typeNameSymbol](): TName {

package/src/simple-tree/node-kinds/map/mapNode.ts

@@ -43,7 +43,12 @@ import {
 	type InsertableContent,
 } from "../../unhydratedFlexTreeFromInsertable.js";
 import { prepareForInsertion } from "../../prepareForInsertion.js";
-import { brand, count, type RestrictiveStringRecord } from "../../../util/index.js";
+import {
+	brand,
+	count,
+	type JsonCompatibleReadOnlyObject,
+	type RestrictiveStringRecord,
+} from "../../../util/index.js";
 import { TreeNodeValid, type MostDerivedData } from "../../treeNodeValid.js";
 import { getUnhydratedContext } from "../../createContext.js";
 import type { MapNodeCustomizableSchema, MapNodePojoEmulationSchema } from "./mapNodeTypes.js";
@@ -215,7 +220,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 		callbackFn: (value: TreeNodeFromImplicitAllowedTypes<T>, key: string, map: TThis) => void,
 		thisArg?: unknown,
 	): void {
-		for (const field of getOrCreateInnerNode(this).boxedIterator()) {
+		for (const field of getOrCreateInnerNode(this)) {
 			const node = getTreeNodeForField(field) as TreeNodeFromImplicitAllowedTypes<T>;
 			callbackFn.call(thisArg, node, field.key, this);
 		}
@@ -228,6 +233,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
  *
  * @param base - base schema type to extend.
  * @param useMapPrototype - should this type emulate a ES6 Map object (by faking its prototype with a proxy).
+ * @param persistedMetadata - Optional persisted metadata for the object node schema.
  */
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function mapSchema<
@@ -241,6 +247,7 @@ export function mapSchema<
 	implicitlyConstructable: ImplicitlyConstructable,
 	useMapPrototype: boolean,
 	metadata?: NodeSchemaMetadata<TCustomMetadata>,
+	persistedMetadata?: JsonCompatibleReadOnlyObject | undefined,
 ) {
 	const lazyChildTypes = new Lazy(() =>
 		normalizeAllowedTypes(unannotateImplicitAllowedTypes(info)),
@@ -294,6 +301,8 @@ export function mapSchema<
 			return lazyChildTypes.value;
 		}
 		public static readonly metadata: NodeSchemaMetadata<TCustomMetadata> = metadata ?? {};
+		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
+			persistedMetadata;
 
 		// eslint-disable-next-line import/no-deprecated
 		public get [typeNameSymbol](): TName {

package/src/simple-tree/node-kinds/object/objectNode.ts

@@ -14,7 +14,11 @@ import {
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
 } from "../../../feature-libraries/index.js";
-import type { RestrictiveStringRecord, FlattenKeys } from "../../../util/index.js";
+import type {
+	RestrictiveStringRecord,
+	FlattenKeys,
+	JsonCompatibleReadOnlyObject,
+} from "../../../util/index.js";
 
 import {
 	type TreeNodeSchema,
@@ -349,6 +353,7 @@ abstract class CustomObjectNodeBase<
  *
  * @param name - Unique identifier for this schema within this factory's scope.
  * @param fields - Schema for fields of the object node's schema. Defines what children can be placed under each key.
+ * @param persistedMetadata - Optional persisted metadata for the object node schema.
  */
 export function objectSchema<
 	TName extends string,
@@ -361,6 +366,7 @@ export function objectSchema<
 	implicitlyConstructable: ImplicitlyConstructable,
 	allowUnknownOptionalFields: boolean,
 	metadata?: NodeSchemaMetadata<TCustomMetadata>,
+	persistedMetadata?: JsonCompatibleReadOnlyObject | undefined,
 ): ObjectNodeSchema<TName, T, ImplicitlyConstructable, TCustomMetadata> &
 	ObjectNodeSchemaInternalData {
 	// Field set can't be modified after this since derived data is stored in maps.
@@ -504,6 +510,8 @@ export function objectSchema<
 			return lazyChildTypes.value;
 		}
 		public static readonly metadata: NodeSchemaMetadata<TCustomMetadata> = metadata ?? {};
+		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
+			persistedMetadata;
 
 		// eslint-disable-next-line import/no-deprecated
 		public get [typeNameSymbol](): TName {

package/src/simple-tree/prepareForInsertion.ts

@@ -84,7 +84,11 @@ export function prepareArrayContentForInsertion(
 	validateAndPrepare(
 		getSchemaAndPolicy(destinationContext),
 		destinationContext.isHydrated() ? destinationContext : undefined,
-		{ kind: FieldKinds.sequence.identifier, types: fieldSchema.types },
+		{
+			kind: FieldKinds.sequence.identifier,
+			types: fieldSchema.types,
+			persistedMetadata: undefined,
+		},
 		mapTrees,
 	);
 

package/src/simple-tree/schemaTypes.ts

@@ -20,6 +20,7 @@ import {
 	getOrCreate,
 	type RestrictiveStringRecord,
 	type IsUnion,
+	type JsonCompatibleReadOnlyObject,
 } from "../util/index.js";
 
 import type {
@@ -297,7 +298,23 @@ export interface FieldProps<TCustomMetadata = unknown> {
 }
 
 /**
- * A {@link FieldProvider} which prefers to have additional context in order to produce its content.
+ * {@link FieldProps} extended with additional `alpha` options.
+ *
+ * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.
+ * See {@link FieldSchemaMetadata.custom}.
+ *
+ * @alpha @input
+ */
+export interface FieldPropsAlpha<TCustomMetadata = unknown>
+	extends FieldProps<TCustomMetadata> {
+	/**
+	 * The persisted metadata for this schema element.
+	 */
+	readonly persistedMetadata?: JsonCompatibleReadOnlyObject | undefined;
+}
+
+/**
+ * A {@link FieldProvider} which requires additional context in order to produce its content
  */
 export type ContextualFieldProvider = (
 	context: FlexTreeHydratedContextMinimal | "UseGlobalContext",
@@ -361,6 +378,22 @@ export interface FieldSchemaMetadata<TCustomMetadata = unknown> {
 	readonly description?: string | undefined;
 }
 
+/**
+ * Metadata associated with a {@link FieldSchema}. Includes fields used by alpha features.
+ *
+ * @remarks Specified via {@link FieldProps.metadata}.
+ *
+ * @sealed
+ * @alpha
+ */
+export interface FieldSchemaMetadataAlpha<TCustomMetadata = unknown>
+	extends FieldSchemaMetadata<TCustomMetadata> {
+	/**
+	 * The persisted metadata for this schema element.
+	 */
+	readonly persistedMetadata?: JsonCompatibleReadOnlyObject | undefined;
+}
+
 /**
  * Package internal construction API.
  */
@@ -509,12 +542,20 @@ export class FieldSchemaAlpha<
 {
 	private readonly lazyIdentifiers: Lazy<ReadonlySet<string>>;
 	private readonly lazyAnnotatedTypes: Lazy<ReadonlyMap<TreeNodeSchema, AllowedTypeMetadata>>;
+	private readonly propsAlpha: FieldPropsAlpha<TCustomMetadata> | undefined;
 
 	/**
 	 * Metadata on the types of tree nodes allowed on this field.
 	 */
 	public readonly allowedTypesMetadata: AllowedTypesMetadata;
 
+	/**
+	 * Persisted metadata for this field schema.
+	 */
+	public get persistedMetadata(): JsonCompatibleReadOnlyObject | undefined {
+		return this.propsAlpha?.persistedMetadata;
+	}
+
 	static {
 		createFieldSchemaPrivate = <
 			Kind2 extends FieldKind,
@@ -523,7 +564,7 @@ export class FieldSchemaAlpha<
 		>(
 			kind: Kind2,
 			annotatedAllowedTypes: Types2,
-			props?: FieldProps<TCustomMetadata2>,
+			props?: FieldPropsAlpha<TCustomMetadata2>,
 		) =>
 			new FieldSchemaAlpha(
 				kind,
@@ -537,7 +578,7 @@ export class FieldSchemaAlpha<
 		kind: Kind,
 		types: Types,
 		public readonly annotatedAllowedTypes: ImplicitAnnotatedAllowedTypes,
-		props?: FieldProps<TCustomMetadata>,
+		props?: FieldPropsAlpha<TCustomMetadata>,
 	) {
 		super(kind, types, props);
 
@@ -550,6 +591,7 @@ export class FieldSchemaAlpha<
 		this.lazyIdentifiers = new Lazy(
 			() => new Set([...this.allowedTypeSet].map((t) => t.identifier)),
 		);
+		this.propsAlpha = props;
 	}
 
 	public get allowedTypesIdentifiers(): ReadonlySet<string> {
@@ -775,17 +817,48 @@ function areFieldPropsEqual(a: FieldProps | undefined, b: FieldProps | undefined
  * @remarks FieldSchemaMetadata are considered equivalent if their custom data and descriptions are (respectively) reference equal.
  */
 function areMetadataEqual(
-	a: FieldSchemaMetadata | undefined,
-	b: FieldSchemaMetadata | undefined,
+	a: FieldSchemaMetadataAlpha | undefined,
+	b: FieldSchemaMetadataAlpha | undefined,
 ): boolean {
 	// If any new fields are added to FieldSchemaMetadata, this check will stop compiling as a reminder that this function needs to be updated.
-	type _keys = requireTrue<areOnlyKeys<FieldSchemaMetadata, "custom" | "description">>;
+	type _keys = requireTrue<
+		areOnlyKeys<FieldSchemaMetadataAlpha, "custom" | "description" | "persistedMetadata">
+	>;
 
 	if (a === b) {
 		return true;
 	}
 
-	return a?.custom === b?.custom && a?.description === b?.description;
+	return (
+		Object.is(a?.custom, b?.custom) &&
+		a?.description === b?.description &&
+		arePersistedMetadataEqual(a?.persistedMetadata, b?.persistedMetadata)
+	);
+}
+
+/**
+ * Returns true if the given persisted metadata fields are equivalent, otherwise false.
+ * @remarks
+ * Currently only handles shallow equality in the case where the keys are in the same order. This is acceptable for current use cases.
+ */
+function arePersistedMetadataEqual(
+	a: JsonCompatibleReadOnlyObject | undefined,
+	b: JsonCompatibleReadOnlyObject | undefined,
+): boolean {
+	if (Object.is(a, b)) {
+		return true;
+	}
+
+	if (a === undefined || b === undefined) {
+		return false;
+	}
+
+	// Note that the key order matters. If `a` and `b` have the same content but the keys are in a different order,
+	// this method will return false.
+	const aStringified = JSON.stringify(a);
+	const bStringified = JSON.stringify(b);
+
+	return aStringified === bStringified;
 }
 
 const cachedLazyItem = new WeakMap<() => unknown, unknown>();
@@ -1313,6 +1386,22 @@ export interface NodeSchemaOptions<out TCustomMetadata = unknown> {
 	readonly metadata?: NodeSchemaMetadata<TCustomMetadata> | undefined;
 }
 
+/**
+ * Additional information to provide to Node Schema creation. Includes fields for alpha features.
+ *
+ * @typeParam TCustomMetadata - Custom metadata properties to associate with the Node Schema.
+ * See {@link NodeSchemaMetadata.custom}.
+ *
+ * @alpha
+ */
+export interface NodeSchemaOptionsAlpha<out TCustomMetadata = unknown>
+	extends NodeSchemaOptions<TCustomMetadata> {
+	/**
+	 * The persisted metadata for this schema element.
+	 */
+	readonly persistedMetadata?: JsonCompatibleReadOnlyObject | undefined;
+}
+
 /**
  * Metadata associated with a Node Schema.
  *

package/src/simple-tree/simpleSchema.ts

@@ -4,7 +4,7 @@
  */
 
 import type { ValueSchema } from "../core/index.js";
-
+import type { JsonCompatibleReadOnlyObject } from "../util/index.js";
 import type { NodeKind } from "./core/index.js";
 import type { FieldKind, FieldSchemaMetadata, NodeSchemaMetadata } from "./schemaTypes.js";
 
@@ -37,6 +37,23 @@ export interface SimpleNodeSchemaBase<
 	readonly metadata: NodeSchemaMetadata<TCustomMetadata>;
 }
 
+/**
+ * A {@link SimpleNodeSchema} containing fields for alpha features.
+ *
+ * @system
+ * @alpha
+ * @sealed
+ */
+export interface SimpleNodeSchemaBaseAlpha<
+	out TNodeKind extends NodeKind,
+	out TCustomMetadata = unknown,
+> extends SimpleNodeSchemaBase<TNodeKind, TCustomMetadata> {
+	/**
+	 * Persisted metadata for this node schema.
+	 */
+	readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined;
+}
+
 /**
  * A {@link SimpleNodeSchema} for an object node.
  *
@@ -44,7 +61,7 @@ export interface SimpleNodeSchemaBase<
  * @sealed
  */
 export interface SimpleObjectNodeSchema<out TCustomMetadata = unknown>
-	extends SimpleNodeSchemaBase<NodeKind.Object, TCustomMetadata> {
+	extends SimpleNodeSchemaBaseAlpha<NodeKind.Object, TCustomMetadata> {
 	/**
 	 * Schemas for each of the object's fields, keyed off of schema's keys.
 	 * @remarks
@@ -82,7 +99,7 @@ export interface SimpleObjectFieldSchema extends SimpleFieldSchema {
  * @sealed
  */
 export interface SimpleArrayNodeSchema<out TCustomMetadata = unknown>
-	extends SimpleNodeSchemaBase<NodeKind.Array, TCustomMetadata> {
+	extends SimpleNodeSchemaBaseAlpha<NodeKind.Array, TCustomMetadata> {
 	/**
 	 * The types allowed in the array.
 	 *
@@ -99,7 +116,7 @@ export interface SimpleArrayNodeSchema<out TCustomMetadata = unknown>
  * @sealed
  */
 export interface SimpleMapNodeSchema<out TCustomMetadata = unknown>
-	extends SimpleNodeSchemaBase<NodeKind.Map, TCustomMetadata> {
+	extends SimpleNodeSchemaBaseAlpha<NodeKind.Map, TCustomMetadata> {
 	/**
 	 * The types allowed as values in the map.
 	 *
@@ -115,7 +132,7 @@ export interface SimpleMapNodeSchema<out TCustomMetadata = unknown>
  * @alpha
  * @sealed
  */
-export interface SimpleLeafNodeSchema extends SimpleNodeSchemaBase<NodeKind.Leaf> {
+export interface SimpleLeafNodeSchema extends SimpleNodeSchemaBaseAlpha<NodeKind.Leaf> {
 	/**
 	 * The kind of leaf node.
 	 */
@@ -170,6 +187,11 @@ export interface SimpleFieldSchema {
 	 * {@inheritDoc FieldSchemaMetadata}
 	 */
 	readonly metadata: FieldSchemaMetadata;
+
+	/**
+	 * Persisted metadata for this field schema.
+	 */
+	readonly persistedMetadata?: JsonCompatibleReadOnlyObject | undefined;
 }
 
 /**

package/src/simple-tree/toStoredSchema.ts

@@ -90,7 +90,7 @@ export function convertField(schema: SimpleFieldSchema): TreeFieldStoredSchema {
 	const kind: FieldKindIdentifier =
 		convertFieldKind.get(schema.kind)?.identifier ?? fail(0xae3 /* Invalid field kind */);
 	const types: TreeTypeSet = schema.allowedTypesIdentifiers as TreeTypeSet;
-	return { kind, types };
+	return { kind, types, persistedMetadata: schema.persistedMetadata };
 }
 
 /**
@@ -107,6 +107,8 @@ export const convertFieldKind: ReadonlyMap<FieldKind, FlexFieldKind> = new Map<
 
 /**
  * Converts a {@link TreeNodeSchema} into a {@link TreeNodeStoredSchema}.
+ * @privateRemarks
+ * TODO: Persist node metadata once schema FormatV2 is supported.
  */
 export function getStoredSchema(schema: SimpleNodeSchema): TreeNodeStoredSchema {
 	const kind = schema.kind;
@@ -117,23 +119,32 @@ export function getStoredSchema(schema: SimpleNodeSchema): TreeNodeStoredSchema
 		}
 		case NodeKind.Map: {
 			const types = schema.allowedTypesIdentifiers as TreeTypeSet;
-			return new MapNodeStoredSchema({ kind: FieldKinds.optional.identifier, types });
+			return new MapNodeStoredSchema(
+				{
+					kind: FieldKinds.optional.identifier,
+					types,
+					persistedMetadata: schema.persistedMetadata,
+				},
+				// TODO: Find a way to avoid injecting persistedMetadata twice in these constructor calls.
+				schema.persistedMetadata,
+			);
 		}
 		case NodeKind.Array: {
 			const types = schema.allowedTypesIdentifiers as TreeTypeSet;
 			const field = {
 				kind: FieldKinds.sequence.identifier,
 				types,
+				persistedMetadata: schema.persistedMetadata,
 			};
 			const fields = new Map([[EmptyKey, field]]);
-			return new ObjectNodeStoredSchema(fields);
+			return new ObjectNodeStoredSchema(fields, schema.persistedMetadata);
 		}
 		case NodeKind.Object: {
 			const fields: Map<FieldKey, TreeFieldStoredSchema> = new Map();
 			for (const fieldSchema of schema.fields.values()) {
 				fields.set(brand(fieldSchema.storedKey), convertField(fieldSchema));
 			}
-			return new ObjectNodeStoredSchema(fields);
+			return new ObjectNodeStoredSchema(fields, schema.persistedMetadata);
 		}
 		default:
 			unreachableCase(kind);

package/src/util/typeUtils.ts

@@ -168,7 +168,7 @@ export type UnionToIntersection<T> = (T extends T ? (k: T) => unknown : never) e
  *
  * @typeparam Union - The union to convert.
  * @typeparam AsOverloadedFunction - Implementation detail: do not specify.
- * @system @alpha
+ * @system @beta
  */
 export type PopUnion<
 	Union,
@@ -189,7 +189,7 @@ export type PopUnion<
  *
  * https://www.hacklewayne.com/typescript-convert-union-to-tuple-array-yes-but-how and https://catchts.com/union-array both explain the general approach this uses pretty well.
  * This implementation is inspired to those, but slightly different in implementation.
- * @alpha
+ * @system @beta
  */
 export type UnionToTuple<
 	Union,

package/src/util/utils.ts

@@ -317,6 +317,7 @@ export type JsonCompatibleObject<TExtra = never> = { [P in string]?: JsonCompati
  * @remarks
  * This does not robustly forbid non json comparable data via type checking,
  * but instead mostly restricts access to it.
+ * @alpha
  */
 export type JsonCompatibleReadOnly =
 	| string
@@ -332,6 +333,7 @@ export type JsonCompatibleReadOnly =
  * @remarks
  * This does not robustly forbid non json comparable data via type checking,
  * but instead mostly restricts access to it.
+ * @alpha
  */
 export type JsonCompatibleReadOnlyObject = { readonly [P in string]?: JsonCompatibleReadOnly };
 

package/dist/feature-libraries/flex-tree/navigation.d.ts

@@ -1,46 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-export declare const Skip: unique symbol;
-export type Skip = typeof Skip;
-/**
- * Visit iterable tree.
- *
- * @remarks
- * Non-recursive depth first traversal.
- */
-export declare function visitIterableTree<T>(root: T, iterator: (t: T) => Iterable<T>, visitor: (item: T) => Skip | void): void;
-/**
- * Visit iterable tree.
- * Allows state to be computed in parents and passed to children.
- *
- * @remarks
- * Non-recursive depth first traversal.
- */
-export declare function visitIterableTreeWithState<T extends Iterable<T>, StatePassedDown>(root: T, initial: StatePassedDown, visitor: (item: T, fromAbove: StatePassedDown) => Skip | StatePassedDown): void;
-/**
- * Visit bipartite iterable tree.
- *
- * @remarks
- * Non-recursive depth first traversal.
- *
- * Particularly useful for processing trees with their alternating node and field levels.
- */
-export declare function visitBipartiteIterableTree<A extends Iterable<B>, B extends Iterable<A>>(root: A, visitorA: (item: A) => Skip | undefined, visitorB: (item: B) => Skip | undefined): void;
-/**
- * Visit bipartite iterable tree.
- * Allows state to be computed in parents and passed to children.
- *
- * @remarks
- * Non-recursive depth first traversal.
- *
- * Particularly useful for processing trees with their alternating node and field levels.
- *
- * @privateRemarks
- * Other traversal cases, like ones passing data up (via map or reduce patterns) could be supported by extending this or adding more utilities.
- * Such utility functions really only provide an improvement of hand coding each cases if the non-recessiveness is required.
- * Since supporting very deeps trees hasn't been a priority, such visitors are also not a priority, and are thus not included here for now.
- */
-export declare function visitBipartiteIterableTreeWithState<A, B, StateA, StateB>(root: A, fromAbove: StateA, iterateA: (a: A) => Iterable<B>, iterateB: (b: B) => Iterable<A>, visitorA: (item: A, fromAbove: StateA) => Skip | StateB, visitorB: (item: B, fromAbove: StateB) => Skip | StateA): void;
-//# sourceMappingURL=navigation.d.ts.map

package/dist/feature-libraries/flex-tree/navigation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/navigation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,IAAI,eAAiB,CAAC;AACnC,MAAM,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC;AAE/B;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAClC,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,EAC/B,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI,GAC/B,IAAI,CAUN;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,QAAQ,CAAC,CAAC,CAAC,EAAE,eAAe,EAChF,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,SAAS,EAAE,eAAe,KAAK,IAAI,GAAG,eAAe,GACtE,IAAI,CAYN;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,QAAQ,CAAC,CAAC,CAAC,EACtF,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,GAAG,SAAS,EACvC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,GAAG,SAAS,GACrC,IAAI,CAcN;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mCAAmC,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EACvE,IAAI,EAAE,CAAC,EACP,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,EACvD,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,GACrD,IAAI,CAgBN"}

package/dist/feature-libraries/flex-tree/navigation.js

@@ -1,104 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.visitBipartiteIterableTreeWithState = exports.visitBipartiteIterableTree = exports.visitIterableTreeWithState = exports.visitIterableTree = exports.Skip = void 0;
-exports.Skip = Symbol("Skip");
-/**
- * Visit iterable tree.
- *
- * @remarks
- * Non-recursive depth first traversal.
- */
-function visitIterableTree(root, iterator, visitor) {
-    const queue = [[root]];
-    let next;
-    while ((next = queue.pop())) {
-        for (const child of next) {
-            if (visitor(child) !== exports.Skip) {
-                queue.push(iterator(child));
-            }
-        }
-    }
-}
-exports.visitIterableTree = visitIterableTree;
-/**
- * Visit iterable tree.
- * Allows state to be computed in parents and passed to children.
- *
- * @remarks
- * Non-recursive depth first traversal.
- */
-function visitIterableTreeWithState(root, initial, visitor) {
-    const queue = [[initial, root]];
-    let next;
-    while ((next = queue.pop())) {
-        const [state, nestItem] = next;
-        for (const child of nestItem) {
-            const result = visitor(child, state);
-            if (result !== exports.Skip) {
-                queue.push([result, child]);
-            }
-        }
-    }
-}
-exports.visitIterableTreeWithState = visitIterableTreeWithState;
-/**
- * Visit bipartite iterable tree.
- *
- * @remarks
- * Non-recursive depth first traversal.
- *
- * Particularly useful for processing trees with their alternating node and field levels.
- */
-function visitBipartiteIterableTree(root, visitorA, visitorB) {
-    const queueA = [root];
-    let nextA;
-    while ((nextA = queueA.pop())) {
-        if (visitorA(nextA) !== exports.Skip) {
-            for (const nextB of nextA) {
-                if (visitorB(nextB) !== exports.Skip) {
-                    for (const child of nextB) {
-                        queueA.push(child);
-                    }
-                }
-            }
-        }
-    }
-}
-exports.visitBipartiteIterableTree = visitBipartiteIterableTree;
-/**
- * Visit bipartite iterable tree.
- * Allows state to be computed in parents and passed to children.
- *
- * @remarks
- * Non-recursive depth first traversal.
- *
- * Particularly useful for processing trees with their alternating node and field levels.
- *
- * @privateRemarks
- * Other traversal cases, like ones passing data up (via map or reduce patterns) could be supported by extending this or adding more utilities.
- * Such utility functions really only provide an improvement of hand coding each cases if the non-recessiveness is required.
- * Since supporting very deeps trees hasn't been a priority, such visitors are also not a priority, and are thus not included here for now.
- */
-function visitBipartiteIterableTreeWithState(root, fromAbove, iterateA, iterateB, visitorA, visitorB) {
-    const queueA = [[root, fromAbove]];
-    let next;
-    while ((next = queueA.pop())) {
-        const result = visitorA(...next);
-        if (result !== exports.Skip) {
-            for (const nextB of iterateA(next[0])) {
-                const resultB = visitorB(nextB, result);
-                if (resultB !== exports.Skip) {
-                    for (const child of iterateB(nextB)) {
-                        queueA.push([child, resultB]);
-                    }
-                }
-            }
-        }
-    }
-}
-exports.visitBipartiteIterableTreeWithState = visitBipartiteIterableTreeWithState;
-//# sourceMappingURL=navigation.js.map

package/dist/feature-libraries/flex-tree/navigation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"navigation.js","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/navigation.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport const Skip = Symbol(\"Skip\");\nexport type Skip = typeof Skip;\n\n/**\n * Visit iterable tree.\n *\n * @remarks\n * Non-recursive depth first traversal.\n */\nexport function visitIterableTree<T>(\n\troot: T,\n\titerator: (t: T) => Iterable<T>,\n\tvisitor: (item: T) => Skip | void,\n): void {\n\tconst queue: Iterable<T>[] = [[root]];\n\tlet next: Iterable<T> | undefined;\n\twhile ((next = queue.pop())) {\n\t\tfor (const child of next) {\n\t\t\tif (visitor(child) !== Skip) {\n\t\t\t\tqueue.push(iterator(child));\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Visit iterable tree.\n * Allows state to be computed in parents and passed to children.\n *\n * @remarks\n * Non-recursive depth first traversal.\n */\nexport function visitIterableTreeWithState<T extends Iterable<T>, StatePassedDown>(\n\troot: T,\n\tinitial: StatePassedDown,\n\tvisitor: (item: T, fromAbove: StatePassedDown) => Skip | StatePassedDown,\n): void {\n\tconst queue: [StatePassedDown, Iterable<T>][] = [[initial, root]];\n\tlet next: [StatePassedDown, Iterable<T>] | undefined;\n\twhile ((next = queue.pop())) {\n\t\tconst [state, nestItem] = next;\n\t\tfor (const child of nestItem) {\n\t\t\tconst result = visitor(child, state);\n\t\t\tif (result !== Skip) {\n\t\t\t\tqueue.push([result, child]);\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Visit bipartite iterable tree.\n *\n * @remarks\n * Non-recursive depth first traversal.\n *\n * Particularly useful for processing trees with their alternating node and field levels.\n */\nexport function visitBipartiteIterableTree<A extends Iterable<B>, B extends Iterable<A>>(\n\troot: A,\n\tvisitorA: (item: A) => Skip | undefined,\n\tvisitorB: (item: B) => Skip | undefined,\n): void {\n\tconst queueA = [root];\n\tlet nextA: A | undefined;\n\twhile ((nextA = queueA.pop())) {\n\t\tif (visitorA(nextA) !== Skip) {\n\t\t\tfor (const nextB of nextA) {\n\t\t\t\tif (visitorB(nextB) !== Skip) {\n\t\t\t\t\tfor (const child of nextB) {\n\t\t\t\t\t\tqueueA.push(child);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Visit bipartite iterable tree.\n * Allows state to be computed in parents and passed to children.\n *\n * @remarks\n * Non-recursive depth first traversal.\n *\n * Particularly useful for processing trees with their alternating node and field levels.\n *\n * @privateRemarks\n * Other traversal cases, like ones passing data up (via map or reduce patterns) could be supported by extending this or adding more utilities.\n * Such utility functions really only provide an improvement of hand coding each cases if the non-recessiveness is required.\n * Since supporting very deeps trees hasn't been a priority, such visitors are also not a priority, and are thus not included here for now.\n */\nexport function visitBipartiteIterableTreeWithState<A, B, StateA, StateB>(\n\troot: A,\n\tfromAbove: StateA,\n\titerateA: (a: A) => Iterable<B>,\n\titerateB: (b: B) => Iterable<A>,\n\tvisitorA: (item: A, fromAbove: StateA) => Skip | StateB,\n\tvisitorB: (item: B, fromAbove: StateB) => Skip | StateA,\n): void {\n\tconst queueA: [A, StateA][] = [[root, fromAbove]];\n\tlet next: [A, StateA] | undefined;\n\twhile ((next = queueA.pop())) {\n\t\tconst result = visitorA(...next);\n\t\tif (result !== Skip) {\n\t\t\tfor (const nextB of iterateA(next[0])) {\n\t\t\t\tconst resultB = visitorB(nextB, result);\n\t\t\t\tif (resultB !== Skip) {\n\t\t\t\t\tfor (const child of iterateB(nextB)) {\n\t\t\t\t\t\tqueueA.push([child, resultB]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n"]}