@fluidframework/tree 2.42.0 → 2.43.0

package/src/simple-tree/schemaTypes.ts

@@ -20,6 +20,7 @@ import {
 	getOrCreate,
 	type RestrictiveStringRecord,
 	type IsUnion,
+	type JsonCompatibleReadOnlyObject,
 } from "../util/index.js";
 
 import type {
@@ -31,8 +32,10 @@ import type {
 	TreeNodeSchemaCore,
 	TreeNodeSchemaNonClass,
 	UnhydratedFlexTreeNode,
+	AnnotatedAllowedType,
+	NormalizedAnnotatedAllowedTypes,
 } from "./core/index.js";
-import { inPrototypeChain } from "./core/index.js";
+import { inPrototypeChain, isAnnotatedAllowedTypes } from "./core/index.js";
 import { isLazy, type FlexListToUnion, type LazyItem } from "./flexList.js";
 import { LeafNodeSchema } from "./leafNodeSchema.js";
 import type { SimpleFieldSchema, SimpleObjectFieldSchema } from "./simpleSchema.js";
@@ -105,17 +108,6 @@ export interface AnnotatedAllowedTypes {
 	readonly types: readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[];
 }
 
-/**
- * Checks if the input is an {@link AnnotatedAllowedTypes}.
- */
-export function isAnnotatedAllowedTypes(
-	allowedTypes: ImplicitAnnotatedAllowedTypes,
-): allowedTypes is AnnotatedAllowedTypes {
-	return (
-		typeof allowedTypes === "object" && "metadata" in allowedTypes && "types" in allowedTypes
-	);
-}
-
 /**
  * Annotations that apply to a set of allowed types.
  * @remarks
@@ -129,21 +121,6 @@ export interface AllowedTypesMetadata {
 	readonly custom?: unknown;
 }
 
-/**
- * Stores annotations for an individual allowed type.
- * @alpha
- */
-export interface AnnotatedAllowedType<T extends TreeNodeSchema = TreeNodeSchema> {
-	/**
-	 * Annotations for the allowed type.
-	 */
-	readonly metadata: AllowedTypeMetadata;
-	/**
-	 * The allowed type the annotations apply to in a particular schema.
-	 */
-	readonly type: LazyItem<T>;
-}
-
 /**
  * Checks if the given allowed type is annotated with {@link AllowedTypeMetadata}.
  */
@@ -206,7 +183,10 @@ export enum FieldKind {
  * If an explicit stored key was specified in the schema, it will be used.
  * Otherwise, the stored key is the same as the property key.
  */
-export function getStoredKey(propertyKey: string, fieldSchema: ImplicitFieldSchema): FieldKey {
+export function getStoredKey(
+	propertyKey: string,
+	fieldSchema: ImplicitAnnotatedFieldSchema,
+): FieldKey {
 	return brand(getExplicitStoredKey(fieldSchema) ?? propertyKey);
 }
 
@@ -214,7 +194,9 @@ export function getStoredKey(propertyKey: string, fieldSchema: ImplicitFieldSche
  * Gets the {@link FieldProps.key | stored key} specified by the schema, if one was explicitly specified.
  * Otherwise, returns undefined.
  */
-export function getExplicitStoredKey(fieldSchema: ImplicitFieldSchema): string | undefined {
+export function getExplicitStoredKey(
+	fieldSchema: ImplicitAnnotatedFieldSchema,
+): string | undefined {
 	return fieldSchema instanceof FieldSchema ? fieldSchema.props?.key : undefined;
 }
 
@@ -297,7 +279,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 +359,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.
  */
@@ -508,13 +522,21 @@ export class FieldSchemaAlpha<
 	implements SimpleFieldSchema
 {
 	private readonly lazyIdentifiers: Lazy<ReadonlySet<string>>;
-	private readonly lazyAnnotatedTypes: Lazy<ReadonlyMap<TreeNodeSchema, AllowedTypeMetadata>>;
+	private readonly lazyAnnotatedTypes: Lazy<NormalizedAnnotatedAllowedTypes>;
+	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 +545,7 @@ export class FieldSchemaAlpha<
 		>(
 			kind: Kind2,
 			annotatedAllowedTypes: Types2,
-			props?: FieldProps<TCustomMetadata2>,
+			props?: FieldPropsAlpha<TCustomMetadata2>,
 		) =>
 			new FieldSchemaAlpha(
 				kind,
@@ -537,7 +559,7 @@ export class FieldSchemaAlpha<
 		kind: Kind,
 		types: Types,
 		public readonly annotatedAllowedTypes: ImplicitAnnotatedAllowedTypes,
-		props?: FieldProps<TCustomMetadata>,
+		props?: FieldPropsAlpha<TCustomMetadata>,
 	) {
 		super(kind, types, props);
 
@@ -545,11 +567,12 @@ export class FieldSchemaAlpha<
 			? annotatedAllowedTypes.metadata
 			: {};
 		this.lazyAnnotatedTypes = new Lazy(() =>
-			extractAnnotationsFromAllowedTypes(this.annotatedAllowedTypes),
+			normalizeAnnotatedAllowedTypes(annotatedAllowedTypes),
 		);
 		this.lazyIdentifiers = new Lazy(
 			() => new Set([...this.allowedTypeSet].map((t) => t.identifier)),
 		);
+		this.propsAlpha = props;
 	}
 
 	public get allowedTypesIdentifiers(): ReadonlySet<string> {
@@ -560,7 +583,7 @@ export class FieldSchemaAlpha<
 	 * What types of tree nodes are allowed in this field and their annotations.
 	 * @remarks Counterpart to {@link FieldSchemaAlpha.annotatedAllowedTypes}, with any lazy definitions evaluated.
 	 */
-	public get annotatedAllowedTypeSet(): ReadonlyMap<TreeNodeSchema, AllowedTypeMetadata> {
+	public get annotatedAllowedTypesNormalized(): NormalizedAnnotatedAllowedTypes {
 		return this.lazyAnnotatedTypes.value;
 	}
 }
@@ -629,8 +652,8 @@ export function normalizeAllowedTypes(
  * Normalizes an allowed type to an {@link AnnotatedAllowedType}, by adding empty annotations if they don't already exist.
  */
 export function normalizeToAnnotatedAllowedType<T extends TreeNodeSchema>(
-	type: T | AnnotatedAllowedType<T>,
-): AnnotatedAllowedType<T> {
+	type: T | AnnotatedAllowedType<T> | AnnotatedAllowedType<LazyItem<T>>,
+): AnnotatedAllowedType<T> | AnnotatedAllowedType<LazyItem<T>> {
 	return isAnnotatedAllowedType(type)
 		? type
 		: {
@@ -639,6 +662,46 @@ export function normalizeToAnnotatedAllowedType<T extends TreeNodeSchema>(
 			};
 }
 
+/**
+ * Normalizes a {@link ImplicitAnnotatedAllowedTypes} to a set of {@link AnnotatedAllowedSchema}s, by eagerly evaluating any
+ * lazy schema declarations and adding empty metadata if it doesn't already exist.
+ *
+ * @remarks Note: this must only be called after all required schemas have been declared, otherwise evaluation of
+ * recursive schemas may fail.
+ */
+export function normalizeAnnotatedAllowedTypes(
+	types: ImplicitAnnotatedAllowedTypes,
+): NormalizedAnnotatedAllowedTypes {
+	const typesWithoutAnnotation = isAnnotatedAllowedTypes(types) ? types.types : types;
+	const annotatedTypes: AnnotatedAllowedType<TreeNodeSchema>[] = [];
+	if (isReadonlyArray(typesWithoutAnnotation)) {
+		for (const annotatedType of typesWithoutAnnotation) {
+			if (isAnnotatedAllowedType(annotatedType)) {
+				annotatedTypes.push({
+					type: evaluateLazySchema(annotatedType.type),
+					metadata: annotatedType.metadata,
+				});
+			} else {
+				annotatedTypes.push({ type: evaluateLazySchema(annotatedType), metadata: {} });
+			}
+		}
+	} else {
+		if (isAnnotatedAllowedType(typesWithoutAnnotation)) {
+			annotatedTypes.push({
+				type: evaluateLazySchema(typesWithoutAnnotation.type),
+				metadata: typesWithoutAnnotation.metadata,
+			});
+		} else {
+			annotatedTypes.push({ type: evaluateLazySchema(typesWithoutAnnotation), metadata: {} });
+		}
+	}
+
+	return {
+		metadata: isAnnotatedAllowedTypes(types) ? types.metadata : {},
+		types: annotatedTypes,
+	};
+}
+
 /**
  * Converts an {@link ImplicitAnnotatedAllowedTypes} to an {@link ImplicitAllowedTypes}s, by removing
  * any annotations.
@@ -677,36 +740,6 @@ export function unannotateSchemaRecord<
 	) as UnannotateSchemaRecord<Schema>;
 }
 
-/**
- * Converts annotated allowed types into a mapping between the type schema and their associated annotations.
- */
-export function extractAnnotationsFromAllowedTypes(
-	types: ImplicitAnnotatedAllowedTypes,
-): ReadonlyMap<TreeNodeSchema, AllowedTypeMetadata> {
-	const typesWithoutAnnotation = isAnnotatedAllowedTypes(types) ? types.types : types;
-	const annotations = new Map<TreeNodeSchema, AllowedTypeMetadata>();
-	if (isReadonlyArray(typesWithoutAnnotation)) {
-		for (const annotatedType of typesWithoutAnnotation) {
-			if (isAnnotatedAllowedType(annotatedType)) {
-				annotations.set(evaluateLazySchema(annotatedType.type), annotatedType.metadata);
-			} else {
-				annotations.set(evaluateLazySchema(annotatedType), {});
-			}
-		}
-	} else {
-		if (isAnnotatedAllowedType(typesWithoutAnnotation)) {
-			annotations.set(
-				evaluateLazySchema(typesWithoutAnnotation.type),
-				typesWithoutAnnotation.metadata,
-			);
-		} else {
-			annotations.set(evaluateLazySchema(typesWithoutAnnotation), {});
-		}
-	}
-
-	return annotations;
-}
-
 /**
  * Returns true if the given {@link ImplicitFieldSchema} are equivalent, otherwise false.
  * @remarks Two ImplicitFieldSchema are considered equivalent if all of the following are true:
@@ -775,17 +808,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 +1377,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

@@ -37,6 +37,8 @@ const viewToStoredCache = new WeakMap<ImplicitFieldSchema, TreeStoredSchema>();
 
 /**
  * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema}.
+ * @throws
+ * Throws a `UsageError` if multiple schemas are encountered with the same identifier.
  */
 export function toStoredSchema(root: ImplicitFieldSchema): TreeStoredSchema {
 	return getOrCreate(viewToStoredCache, root, () => {
@@ -90,7 +92,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 +109,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 +121,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/simple-tree/treeNodeValid.ts

@@ -20,8 +20,8 @@ import {
 	type InnerNode,
 	type Context,
 	type UnhydratedFlexTreeNode,
+	getSimpleNodeSchemaFromInnerNode,
 } from "./core/index.js";
-import { getSimpleNodeSchemaFromInnerNode } from "./core/index.js";
 import { markEager } from "./flexList.js";
 
 /**

package/src/simple-tree/walkFieldSchema.ts

@@ -14,5 +14,9 @@ export function walkFieldSchema(
 	visitor: SchemaVisitor,
 	visitedSet: Set<TreeNodeSchema> = new Set(),
 ): void {
-	walkAllowedTypes(normalizeFieldSchema(schema).allowedTypeSet, visitor, visitedSet);
+	walkAllowedTypes(
+		normalizeFieldSchema(schema).annotatedAllowedTypesNormalized,
+		visitor,
+		visitedSet,
+	);
 }

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"}