@fluidframework/tree 2.1.0 → 2.3.0-288113

package/src/util/nestedMap.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import { oob } from "@fluidframework/core-utils/internal";
 import type { MapGetSet } from "./utils.js";
 
 /**
@@ -11,22 +12,16 @@ import type { MapGetSet } from "./utils.js";
  * If you need constant-time access to the number of values, use SizedNestedMap instead.
  *
  * This code assumes values will not be undefined (keys can be undefined).
- *
- * @internal
  */
 export type NestedMap<Key1, Key2, Value> = Map<Key1, Map<Key2, Value>>;
 
 /**
  * A read-only version of {@link NestedMap}.
- *
- * @internal
  */
 export type ReadonlyNestedMap<Key1, Key2, Value> = ReadonlyMap<Key1, ReadonlyMap<Key2, Value>>;
 
 /**
  * If (key1, key2) already has a value in the map, it is returned, otherwise value is added under (key1, key2) and undefined is returned.
- *
- * @internal
  */
 export function tryAddToNestedMap<Key1, Key2, Value>(
 	map: NestedMap<Key1, Key2, Value>,
@@ -55,7 +50,6 @@ export function tryAddToNestedMap<Key1, Key2, Value>(
  *
  * @remarks - This function performs deep copying when necessary.
  * This ensures that mutating `destination` after this call will not result in unexpected mutations to `source`.
- * @internal
  */
 export function populateNestedMap<Key1, Key2, Value>(
 	source: ReadonlyNestedMap<Key1, Key2, Value>,
@@ -80,8 +74,6 @@ export function populateNestedMap<Key1, Key2, Value>(
 /**
  * Sets the value at (key1, key2) in map to value.
  * If there already is a value for (key1, key2), it is replaced with the provided one.
- *
- * @internal
  */
 export function setInNestedMap<Key1, Key2, Value>(
 	map: NestedMap<Key1, Key2, Value>,
@@ -111,10 +103,27 @@ export function getOrAddInMap<Key, Value>(
 	return value;
 }
 
+/**
+ * Sets the value at `key` in `map` to `generateValue()` if not already present.
+ * Returns the value at `key` after setting it.
+ */
+export function getOrAddInMapLazy<Key, Value>(
+	map: MapGetSet<Key, Value>,
+	key: Key,
+	generateValue: () => Value,
+): Value {
+	const currentValue = map.get(key);
+	if (currentValue !== undefined) {
+		return currentValue;
+	}
+
+	const value = generateValue();
+	map.set(key, value);
+	return value;
+}
+
 /**
  * Returns the value at (key1, key2) in map, or undefined if not present.
- *
- * @internal
  */
 export function tryGetFromNestedMap<Key1, Key2, Value>(
 	map: NestedMap<Key1, Key2, Value>,
@@ -131,8 +140,6 @@ export function tryGetFromNestedMap<Key1, Key2, Value>(
 /**
  * If (key1, key2) is not in the map, add value to the map.
  * Returns whatever is at (key1, key2) in map (which will be value if it was empty before).
- *
- * @internal
  */
 export function getOrAddInNestedMap<Key1, Key2, Value>(
 	map: NestedMap<Key1, Key2, Value>,
@@ -151,8 +158,6 @@ export function getOrAddInNestedMap<Key1, Key2, Value>(
  * Does not change map.
  * If (key1, key2) is not in map, returns value.
  * If (key1, key2) is in map, return its entry.
- *
- * @internal
  */
 export function getOrDefaultInNestedMap<Key1, Key2, Value>(
 	map: NestedMap<Key1, Key2, Value>,
@@ -171,8 +176,6 @@ export function getOrDefaultInNestedMap<Key1, Key2, Value>(
  * Removes the value at (key1, key2) from the map.
  *
  * @returns true iff found.
- *
- * @internal
  */
 export function deleteFromNestedMap<Key1, Key2, Value>(
 	map: NestedMap<Key1, Key2, Value>,
@@ -255,8 +258,6 @@ export function mapNestedMap<Key1, Key2, ValueIn, ValueOut = ValueIn>(
 /**
  * Map with two keys; same semantics as NestedMap, but maintains a size count for the entire collection.
  * Note: undefined is not supported as a value, and will cause incorrect behavior.
- *
- * @internal
  */
 export class SizedNestedMap<Key1, Key2, Value> {
 	private readonly nestedMap: NestedMap<Key1, Key2, Value> = new Map();
@@ -336,7 +337,9 @@ export class SizedNestedMap<Key1, Key2, Value> {
 	}
 
 	public values(): IterableIterator<Value> {
-		return Array.from(this.nestedMap.values()).flatMap((innerMap) => innerMap.values())[0];
+		return (
+			Array.from(this.nestedMap.values()).flatMap((innerMap) => innerMap.values())[0] ?? oob()
+		);
 	}
 
 	public [Symbol.iterator](): IterableIterator<[Key1, Map<Key2, Value>]> {

package/src/util/opaque.ts

@@ -22,7 +22,6 @@ import type { isAny } from "./typeCheck.js";
  * ```typescript
  * export interface MyType extends Opaque<Brand<string, "myPackage.MyType">>{}
  * ```
- * @internal
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Opaque<T extends Brand<any, unknown>> = T extends BrandedType<
@@ -34,7 +33,6 @@ export type Opaque<T extends Brand<any, unknown>> = T extends BrandedType<
 
 /**
  * See {@link extractFromOpaque}.
- * @internal
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type ExtractFromOpaque<TOpaque extends BrandedType<any, unknown>> =
@@ -49,7 +47,6 @@ export type ExtractFromOpaque<TOpaque extends BrandedType<any, unknown>> =
  *
  * It is assumed that only code that produces these "opaque" handles does this conversion,
  * allowing these handles to be considered opaque.
- * @internal
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function extractFromOpaque<TOpaque extends BrandedType<any, unknown>>(
@@ -62,7 +59,6 @@ export function extractFromOpaque<TOpaque extends BrandedType<any, unknown>>(
  * Adds a type {@link Brand} to a value, returning it as a {@link Opaque} handle.
  *
  * Only do this when specifically allowed by the requirements of the type being converted to.
- * @internal
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function brandOpaque<T extends BrandedType<any, unknown>>(

package/src/util/rangeMap.ts

@@ -3,6 +3,8 @@
  * Licensed under the MIT License.
  */
 
+import { oob } from "@fluidframework/core-utils/internal";
+
 /**
  * A map keyed on integers allowing reading and writing contiguous ranges of integer keys.
  *
@@ -18,8 +20,6 @@ export interface RangeEntry<T> {
 
 /**
  * The result of a query about a range of keys.
- *
- * @internal
  */
 export interface RangeQueryResult<T> {
 	/**
@@ -112,9 +112,9 @@ export function setInRangeMap<T>(
 	}
 
 	const iFirst = iBefore + 1;
-	const firstEntry = map[iFirst];
+	const firstEntry = map[iFirst] ?? oob();
 	const iLast = iAfter - 1;
-	const lastEntry = map[iLast];
+	const lastEntry = map[iLast] ?? oob();
 	const lengthBeforeFirst = start - firstEntry.start;
 	const lastEntryKey = lastEntry.start + lastEntry.length - 1;
 	const lengthAfterLast = lastEntryKey - end;
@@ -203,7 +203,7 @@ export function deleteFromRangeMap<T>(map: RangeMap<T>, start: number, length: n
 
 	// Update or remove the overlapping entries
 	for (let i = iFirst; i <= iLast; ++i) {
-		const entry = map[i];
+		const entry = map[i] ?? oob();
 		const entryLastKey = entry.start + entry.length - 1;
 		let isDirty = false;
 

package/src/util/transactionResult.ts

@@ -6,7 +6,6 @@
 /**
  * Describes the result of a transaction.
  * Transactions may either succeed and commit, or fail and abort.
- * @internal
  */
 export enum TransactionResult {
 	/**

package/src/util/typeCheck.ts

@@ -45,7 +45,7 @@ export type { EnforceTypeCheckTests } from "./typeCheckTests.js";
  *
  * Typical usages (use one field like this at the top of a class):
  * ```typescript
- * protected _typeCheck?: MakeNominal;
+ * protected _typeCheck!: MakeNominal;
  * protected _typeCheck?: Contravariant<T>;
  * protected _typeCheck?: Covariant<T>;
  * protected _typeCheck?: Invariant<T>;
@@ -78,7 +78,7 @@ export type { EnforceTypeCheckTests } from "./typeCheckTests.js";
  * can use this to prevent undesired assignments.
  * @example
  * ```typescript
- * protected _typeCheck?: MakeNominal;
+ * protected _typeCheck!: MakeNominal;
  * ```
  * @privateRemarks
  * See: {@link https://dev.azure.com/intentional/intent/_wiki/wikis/NP%20Platform/7146/Nominal-vs-Structural-Types}
@@ -94,8 +94,6 @@ export interface MakeNominal {}
  * ```typescript
  * protected _typeCheck?: Contravariant<T>;
  * ```
- *
- * @internal
  */
 export interface Contravariant<in T> {
 	_removeCovariance?: (_: T) => void;
@@ -124,8 +122,6 @@ export interface Covariant<out T> {
  * ```typescript
  * protected _typeCheck?: Invariant<T>;
  * ```
- *
- * @internal
  */
 export interface Invariant<in out T> extends Contravariant<T>, Covariant<T> {}
 
@@ -133,8 +129,6 @@ export interface Invariant<in out T> extends Contravariant<T>, Covariant<T> {}
  * Compile time assert that X is True.
  * To use, simply define a type:
  * `type _check = requireTrue<your type check>;`
- *
- * @internal
  */
 export type requireTrue<_X extends true> = true;
 
@@ -142,8 +136,6 @@ export type requireTrue<_X extends true> = true;
  * Compile time assert that X is False.
  * To use, simply define a type:
  * `type _check = requireFalse<your type check>;`
- *
- * @internal
  */
 export type requireFalse<_X extends false> = true;
 
@@ -153,7 +145,6 @@ export type requireFalse<_X extends false> = true;
  * @privateRemarks
  * Use of [] in the extends clause prevents unions from being distributed over this conditional and returning `boolean` in some cases.
  * @see {@link https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types | distributive-conditional-types} for details.
- * @internal
  */
 export type isAssignableTo<Source, Destination> = [Source] extends [Destination]
 	? true
@@ -161,8 +152,6 @@ export type isAssignableTo<Source, Destination> = [Source] extends [Destination]
 
 /**
  * Returns a type parameter that is true iff Subset is a strict subset of Superset.
- *
- * @internal
  */
 export type isStrictSubset<Subset, Superset> = isAssignableTo<Subset, Superset> extends false
 	? false
@@ -173,8 +162,6 @@ export type isStrictSubset<Subset, Superset> = isAssignableTo<Subset, Superset>
 /**
  * Returns a type parameter that is true iff A and B are assignable to each other, and neither is any.
  * This is useful for checking if the output of a type meta-function is the expected type.
- *
- * @internal
  */
 export type areSafelyAssignable<A, B> = eitherIsAny<A, B> extends true
 	? false
@@ -184,8 +171,6 @@ export type areSafelyAssignable<A, B> = eitherIsAny<A, B> extends true
 
 /**
  * Returns a type parameter that is true iff A is any or B is any.
- *
- * @internal
  */
 export type eitherIsAny<A, B> = true extends isAny<A> | isAny<B> ? true : false;
 
@@ -196,7 +181,6 @@ export type eitherIsAny<A, B> = true extends isAny<A> | isAny<B> ? true : false;
  * Only `never` is assignable to `never` (`any` isn't),
  * but `any` distributes over the `extends` here while nothing else should.
  * This can be used to detect `any`.
- * @internal
  */
 export type isAny<T> = boolean extends (T extends never ? true : false) ? true : false;
 
@@ -204,7 +188,5 @@ export type isAny<T> = boolean extends (T extends never ? true : false) ? true :
  * Compile time assert that A is assignable to (extends) B.
  * To use, simply define a type:
  * `type _check = requireAssignableTo<T, Expected>;`
- *
- * @internal
  */
 export type requireAssignableTo<_A extends B, B> = true;

package/src/util/typeCheckTests.ts

@@ -33,19 +33,19 @@ declare class Empty1 {}
 declare class Empty2 {}
 
 declare class Nominal1 {
-	protected _typeCheck?: MakeNominal;
+	protected _typeCheck: MakeNominal;
 }
 
 declare class Nominal2 {
-	protected _typeCheck?: MakeNominal;
+	protected _typeCheck: MakeNominal;
 }
 
 declare class Derived1 extends Nominal1 {
-	protected _typeCheck?: MakeNominal;
+	protected _typeCheck: MakeNominal;
 }
 
 declare class Derived2 extends Nominal1 {
-	protected _typeCheck?: MakeNominal;
+	protected _typeCheck: MakeNominal;
 }
 
 declare class Generic<_T> {}

package/src/util/typeUtils.ts

@@ -16,7 +16,6 @@ export type FlattenKeys<T> = [{ [Property in keyof T]: T[Property] }][_InlineTri
 
 /**
  * Remove all fields which permit undefined from `T`.
- * @internal
  */
 export type RequiredFields<T> = [
 	{
@@ -26,7 +25,6 @@ export type RequiredFields<T> = [
 
 /**
  * Extract fields which permit undefined but can also hold other types.
- * @internal
  */
 export type OptionalFields<T> = [
 	{
@@ -48,7 +46,6 @@ export type OptionalFields<T> = [
  * flattening since it causes complication issues.
  *
  * See also `AllowOptional`.
- * @internal
  */
 // export type AllowOptionalNotFlattened<T> = [RequiredFields<T> & OptionalFields<T>][_InlineTrick];
 export type AllowOptionalNotFlattened<T> = [
@@ -58,7 +55,6 @@ export type AllowOptionalNotFlattened<T> = [
 /**
  * Converts properties of an object which permit undefined into optional properties.
  * Removes fields which only allow undefined.
- * @internal
  */
 export type AllowOptional<T> = [
 	FlattenKeys<RequiredFields<T> & OptionalFields<T>>,
@@ -126,7 +122,6 @@ export type _InlineTrick = 0;
  *
  * This constant is defined to provide a way to find this documentation from types which use this pattern,
  * and to locate types which use this pattern in case they need updating for compiler changes.
- * @internal
  */
 export type _RecursiveTrick = never;
 
@@ -180,8 +175,6 @@ export type RestrictiveReadonlyRecord<K extends symbol | string, T> = {
  * In these cases `TInput` can be replaced with `Assume<TInput, TAssumeToBe>` to allow compilation of the generic code.
  * When the generic code is parameterized with a concrete type, if that type actually does extend `TAssumeToBe`,
  * it will behave like `TInput` was used directly.
- *
- * @internal
  */
 export type Assume<TInput, TAssumeToBe> = [TInput] extends [TAssumeToBe]
 	? TInput

package/src/util/utils.ts

@@ -48,7 +48,6 @@ export function asMutable<T>(readonly: T): Mutable<T> {
 export const clone = structuredClone;
 
 /**
- * @internal
  */
 export function fail(message: string): never {
 	throw new Error(message);
@@ -205,12 +204,24 @@ export function find<T>(iterable: Iterable<T>, predicate: (t: T) => boolean): T
 	}
 }
 
+/**
+ * Counts the number of elements in the given iterable.
+ * @param iterable - the iterable to enumerate
+ * @returns the number of elements that were iterated after exhausting the iterable
+ */
+export function count(iterable: Iterable<unknown>): number {
+	let n = 0;
+	for (const _ of iterable) {
+		n += 1;
+	}
+	return n;
+}
+
 /**
  * Use for Json compatible data.
  *
  * Note that this does not robustly forbid non json comparable data via type checking,
  * but instead mostly restricts access to it.
- * @internal
  */
 export type JsonCompatible =
 	| string
@@ -226,7 +237,6 @@ export type JsonCompatible =
  *
  * Note that this does not robustly forbid non json comparable data via type checking,
  * but instead mostly restricts access to it.
- * @internal
  */
 export type JsonCompatibleObject = { [P in string]?: JsonCompatible };
 
@@ -386,7 +396,6 @@ export function invertMap<Key, Value>(input: Map<Key, Value>): Map<Value, Key> {
 
 /**
  * Returns the value from `set` if it contains exactly one item, otherwise `undefined`.
- * @internal
  */
 export function oneFromSet<T>(set: ReadonlySet<T> | undefined): T | undefined {
 	if (set === undefined) {
@@ -403,7 +412,6 @@ export function oneFromSet<T>(set: ReadonlySet<T> | undefined): T | undefined {
 /**
  * Type with a name describing what it is.
  * Typically used with values (like schema) that can be stored in a map, but in some representations have their name/key as a field.
- * @internal
  */
 export interface Named<TName> {
 	readonly name: TName;
@@ -411,7 +419,6 @@ export interface Named<TName> {
 
 /**
  * Order {@link Named} objects by their name.
- * @internal
  */
 export function compareNamed(a: Named<string>, b: Named<string>): -1 | 0 | 1 {
 	if (a.name < b.name) {
@@ -427,7 +434,6 @@ export function compareNamed(a: Named<string>, b: Named<string>): -1 | 0 | 1 {
  * Placeholder for `Symbol.dispose`.
  * @privateRemarks
  * TODO: replace this with `Symbol.dispose` when it is available or make it a valid polyfill.
- * @internal
  */
 export const disposeSymbol: unique symbol = Symbol("Symbol.dispose placeholder");
 
@@ -439,7 +445,6 @@ export const disposeSymbol: unique symbol = Symbol("Symbol.dispose placeholder")
  * {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#using-declarations-and-explicit-resource-management| TypeScript's Disposable}.
  *
  * Once this is replaced with TypeScript's Disposable, core-utils/IDisposable can extend it, bringing the APIs into a reasonable alignment.
- * @internal
  */
 export interface IDisposable {
 	/**

package/tsconfig.json

@@ -12,7 +12,6 @@
 		// Linter is used to enforce "_" prefix for unused locals to prevent accidentally having unused locals.
 		"noUnusedLocals": false,
 		"noImplicitOverride": true,
-		"noUncheckedIndexedAccess": false,
 		"exactOptionalPropertyTypes": false,
 	},
 }

package/dist/feature-libraries/contextuallyTyped.d.ts

@@ -1,209 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { type FieldKey, type ITreeCursorSynchronous, type MapTree, type Value } from "../core/index.js";
-import type { TreeDataContext } from "./fieldGenerator.js";
-import type { FlexFieldKind } from "./modular-schema/index.js";
-import type { AllowedTypesToFlexInsertableTree, InsertableFlexField, InsertableFlexNode } from "./schema-aware/index.js";
-import { type AllowedTypeSet, type FlexAllowedTypes, type FlexFieldSchema, type FlexTreeNodeSchema, type FlexTreeSchema } from "./typed-schema/index.js";
-/**
- * This library defines a tree data format that can infer its types from context.
- * It can only be used when the schema is known.
- * The format is optimized for ergonomics when the developer knows the schema,
- * and needs to declare or navigate trees.
- *
- * The format defined here is very tolerant to optimize for flexibility of expressing trees:
- * APIs exposing data in this format should likely further constrain what is allowed.
- * For example guarantee which fields and nodes should be inlined, and that types will be required everywhere.
- *
- * This is from Flex tree one which has been deleted and should no longer be used!
- */
-/**
- * Check if NewFieldContent is made of {@link ITreeCursor}s.
- *
- * Useful when APIs want to take in tree data in multiple formats, including cursors.
- */
-export declare function areCursors(data: NewFieldContent): data is ITreeCursorSynchronous | readonly ITreeCursorSynchronous[];
-/**
- * A symbol for the name of the type of a tree in contexts where string keys are already in use for fields.
- * See {@link TreeNodeSchemaIdentifier}.
- * @internal
- */
-export declare const typeNameSymbol: unique symbol;
-/**
- * A symbol for the value of a tree node in contexts where string keys are already in use for fields.
- * @internal
- */
-export declare const valueSymbol: unique symbol;
-export declare function getFieldKind(fieldSchema: FlexFieldSchema): FlexFieldKind;
-/**
- * @returns all allowed child types for `typeSet`.
- */
-export declare function getAllowedTypes(schemaData: FlexTreeSchema, typeSet: AllowedTypeSet): ReadonlySet<FlexTreeNodeSchema>;
-/**
- * @returns all types, for which the data is schema-compatible.
- */
-export declare function getPossibleTypes(context: FlexTreeSchema, typeSet: AllowedTypeSet, data: ContextuallyTypedNodeData): FlexTreeNodeSchema[];
-/**
- * A symbol used to define a {@link MarkedArrayLike} interface.
- * @internal
- */
-export declare const arrayLikeMarkerSymbol: unique symbol;
-/**
- * Can be used to mark a type which works like an array, but is not compatible with `Array.isArray`.
- * @internal
- */
-export interface MarkedArrayLike<TGet, TSet extends TGet = TGet> extends ArrayLikeMut<TGet, TSet> {
-    readonly [arrayLikeMarkerSymbol]: true;
-    [Symbol.iterator](): IterableIterator<TGet>;
-}
-/**
- * Can be used to mark a type which works like an array, but is not compatible with `Array.isArray`.
- * @internal
- */
-export interface ReadonlyMarkedArrayLike<T> extends ArrayLike<T> {
-    readonly [arrayLikeMarkerSymbol]: true;
-    [Symbol.iterator](): IterableIterator<T>;
-}
-/**
- * `ArrayLike` numeric indexed access, but writable.
- *
- * @remarks
- * Note that due to language limitations, this also allows reading as TSet.
- * This is why `TSet extends TGet` is required.
- *
- * See https://github.com/microsoft/TypeScript/issues/43826.
- * @internal
- */
-export interface ArrayLikeMut<TGet, TSet extends TGet = TGet> extends ArrayLike<TGet> {
-    [n: number]: TSet;
-}
-/**
- * Content of a tree which needs external schema information to interpret.
- *
- * This format is intended for concise authoring of tree literals when the schema is statically known.
- *
- * Once schema aware APIs are implemented, they can be used to provide schema specific subsets of this type.
- * @internal
- */
-export type ContextuallyTypedNodeData = ContextuallyTypedNodeDataObject | number | string | boolean | null | readonly ContextuallyTypedNodeData[] | MarkedArrayLike<ContextuallyTypedNodeData>;
-/**
- * Content of a field which needs external schema information to interpret.
- *
- * This format is intended for concise authoring of tree literals when the schema is statically known.
- *
- * Once schema aware APIs are implemented, they can be used to provide schema specific subsets of this type.
- * @internal
- */
-export type ContextuallyTypedFieldData = ContextuallyTypedNodeData | undefined;
-/**
- * Checks the type of a `ContextuallyTypedNodeData`.
- */
-export declare function isArrayLike(data: ContextuallyTypedFieldData): data is readonly ContextuallyTypedNodeData[] | ReadonlyMarkedArrayLike<ContextuallyTypedNodeData>;
-/**
- * Checks the type of a `ContextuallyTypedNodeData`.
- * @internal
- */
-export declare function isContextuallyTypedNodeDataObject(data: ContextuallyTypedNodeData | undefined): data is ContextuallyTypedNodeDataObject;
-/**
- * Object case of {@link ContextuallyTypedNodeData}.
- * @internal
- */
-export interface ContextuallyTypedNodeDataObject {
-    /**
-     * Value stored on this node.
-     */
-    readonly [valueSymbol]?: Value;
-    /**
-     * The type of the node.
-     * If this node is well-formed, it must follow this schema.
-     */
-    readonly [typeNameSymbol]?: string;
-    /**
-     * Fields of this node, indexed by their field keys.
-     *
-     * Allow explicit undefined for compatibility with FlexTree, and type-safety on read.
-     */
-    [key: FieldKey]: ContextuallyTypedFieldData;
-    /**
-     * Fields of this node, indexed by their field keys as strings.
-     *
-     * Allow unbranded field keys as a convenience for literals.
-     */
-    [key: string]: ContextuallyTypedFieldData;
-}
-/**
- * Construct a tree from ContextuallyTypedNodeData.
- *
- * TODO: this should probably be refactored into a `try` function which either returns a Cursor or a SchemaError with a path to the error.
- * @returns a cursor in Nodes mode for a single node containing the provided data.
- * @internal
- */
-export declare function cursorFromContextualData(context: TreeDataContext, typeSet: AllowedTypeSet, data: ContextuallyTypedNodeData): ITreeCursorSynchronous;
-/**
- * Strongly typed {@link cursorFromContextualData} for a TreeNodeSchema.
- * @returns a cursor in Nodes mode for a single node containing the provided data.
- * @internal
- */
-export declare function cursorForTypedTreeData<T extends FlexTreeNodeSchema>(context: TreeDataContext, schema: T, data: InsertableFlexNode<T>): ITreeCursorSynchronous;
-/**
- * Strongly typed {@link cursorFromContextualData} for AllowedTypes.
- * @returns a cursor in Nodes mode for a single node containing the provided data.
- * @internal
- */
-export declare function cursorForTypedData<T extends FlexAllowedTypes>(context: TreeDataContext, schema: T, data: AllowedTypesToFlexInsertableTree<T>): ITreeCursorSynchronous;
-/**
- * Construct a tree from ContextuallyTypedNodeData.
- * Returns a cursor in Field mode.
- *
- * TODO: this should probably be refactored into a `try` function which either returns a Cursor or a SchemaError with a path to the error.
- */
-export declare function cursorsFromContextualData(context: TreeDataContext, field: FlexFieldSchema, data: ContextuallyTypedNodeData | undefined): ITreeCursorSynchronous;
-/**
- * Strongly typed {@link cursorsFromContextualData} for a TreeFieldSchema
- * @internal
- */
-export declare function cursorsForTypedFieldData<T extends FlexFieldSchema>(context: TreeDataContext, schema: T, data: InsertableFlexField<T>): ITreeCursorSynchronous;
-/**
- * Construct a MapTree from ContextuallyTypedNodeData.
- *
- * TODO: this should probably be refactored into a `try` function which either returns a MapTree or a SchemaError with a path to the error.
- * TODO: test suite.
- *
- * @remarks
- * This version is only exported as a more testable entry point than `cursorFromContextualData` which keeps the use of `MapTree` as an implementation detail.
- * This should not be reexported from the parent module.
- */
-export declare function applyTypesFromContext(context: TreeDataContext, typeSet: AllowedTypeSet, data: ContextuallyTypedNodeData): MapTree;
-/**
- * Construct a MapTree from ContextuallyTypedNodeData.
- *
- * TODO: this should probably be refactored into a `try` function which either returns a MapTree or a SchemaError with a path to the error.
- * TODO: test suite.
- *
- * @remarks
- * This version is only exported as a more testable entry point than `cursorsFromContextualData` which keeps the use of `MapTree` as an implementation detail.
- * This should not be reexported from the parent module.
- */
-export declare function applyFieldTypesFromContext(context: TreeDataContext, field: FlexFieldSchema, data: ContextuallyTypedFieldData): MapTree[];
-/**
- * Content to use for a field.
- *
- * When used, this content will be deeply copied into the tree, and must comply with the schema.
- *
- * The content must follow the {@link Multiplicity} of the {@link FlexFieldKind}:
- * - use a single cursor for an `optional` or `value` field;
- * - use array of cursors for a `sequence` field;
- *
- * TODO: this should allow a field cursor instead of an array of cursors.
- * TODO: Make this generic so a variant of this type that allows placeholders for detached sequences to consume.
- * @internal
- */
-export type NewFieldContent = ITreeCursorSynchronous | readonly ITreeCursorSynchronous[] | ContextuallyTypedFieldData;
-/**
- * Convert NewFieldContent into ITreeCursorSynchronous.
- * The returned cursor will be in Field mode.
- */
-export declare function normalizeNewFieldContent(context: TreeDataContext, schema: FlexFieldSchema, content: NewFieldContent): ITreeCursorSynchronous;
-//# sourceMappingURL=contextuallyTyped.d.ts.map

package/dist/feature-libraries/contextuallyTyped.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contextuallyTyped.d.ts","sourceRoot":"","sources":["../../src/feature-libraries/contextuallyTyped.ts"],"names":[],"mappings":"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"}