@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

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

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

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

@@ -0,0 +1,57 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onNextChange = exports.TreeStatus = exports.boxedIterator = exports.FlexTreeEntityKind = exports.isFlexTreeNode = exports.isFlexTreeEntity = exports.flexTreeMarker = void 0;
+/**
+ * Indicates that an object is a flex tree.
+ * @internal
+ */
+exports.flexTreeMarker = Symbol("flexTreeMarker");
+function isFlexTreeEntity(t) {
+    return typeof t === "object" && t !== null && exports.flexTreeMarker in t;
+}
+exports.isFlexTreeEntity = isFlexTreeEntity;
+function isFlexTreeNode(t) {
+    return isFlexTreeEntity(t) && t[exports.flexTreeMarker] === FlexTreeEntityKind.Node;
+}
+exports.isFlexTreeNode = isFlexTreeNode;
+/**
+ * @internal
+ */
+var FlexTreeEntityKind;
+(function (FlexTreeEntityKind) {
+    FlexTreeEntityKind[FlexTreeEntityKind["Node"] = 0] = "Node";
+    FlexTreeEntityKind[FlexTreeEntityKind["Field"] = 1] = "Field";
+})(FlexTreeEntityKind || (exports.FlexTreeEntityKind = FlexTreeEntityKind = {}));
+/**
+ * Allows boxed iteration of a tree/field
+ */
+exports.boxedIterator = Symbol();
+/**
+ * Status of the tree that a particular node belongs to.
+ * @beta
+ */
+var TreeStatus;
+(function (TreeStatus) {
+    /**
+     * Is parented under the root field.
+     */
+    TreeStatus[TreeStatus["InDocument"] = 0] = "InDocument";
+    /**
+     * Is not parented under the root field, but can be added back to the original document tree.
+     */
+    TreeStatus[TreeStatus["Removed"] = 1] = "Removed";
+    /**
+     * Is removed and cannot be added back to the original document tree.
+     */
+    TreeStatus[TreeStatus["Deleted"] = 2] = "Deleted";
+})(TreeStatus || (exports.TreeStatus = TreeStatus = {}));
+/**
+ * {@inheritdoc TreeNode.[onNextChange]}
+ */
+exports.onNextChange = Symbol("onNextChange");
+// #endregion
+//# sourceMappingURL=flexTreeTypes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flexTreeTypes.js","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/flexTreeTypes.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAyBH;;;GAGG;AACU,QAAA,cAAc,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;AAEvD,SAAgB,gBAAgB,CAAC,CAAU;IAC1C,OAAO,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI,IAAI,sBAAc,IAAI,CAAC,CAAC;AACnE,CAAC;AAFD,4CAEC;AAED,SAAgB,cAAc,CAAC,CAAU;IACxC,OAAO,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,sBAAc,CAAC,KAAK,kBAAkB,CAAC,IAAI,CAAC;AAC7E,CAAC;AAFD,wCAEC;AAED;;GAEG;AACH,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC7B,2DAAI,CAAA;IACJ,6DAAK,CAAA;AACN,CAAC,EAHW,kBAAkB,kCAAlB,kBAAkB,QAG7B;AAED;;GAEG;AACU,QAAA,aAAa,GAAG,MAAM,EAAE,CAAC;AAqDtC;;;GAGG;AACH,IAAY,UAeX;AAfD,WAAY,UAAU;IACrB;;OAEG;IACH,uDAAc,CAAA;IAEd;;OAEG;IACH,iDAAW,CAAA;IAEX;;OAEG;IACH,iDAAW,CAAA;AACZ,CAAC,EAfW,UAAU,0BAAV,UAAU,QAerB;AAED;;GAEG;AACU,QAAA,YAAY,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;AAw4BnD,aAAa","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { AllowedTypesToFlexInsertableTree, InsertableFlexField } from \"../schema-aware\";\nimport { FieldKey, ITreeCursorSynchronous, TreeNodeSchemaIdentifier, TreeValue } from \"../../core\";\nimport { Assume, FlattenKeys } from \"../../util\";\nimport { LocalNodeKey, StableNodeKey } from \"../node-key\";\nimport {\n\tTreeFieldSchema,\n\tInternalTypedSchemaTypes,\n\tTreeNodeSchema,\n\tAllowedTypes,\n\tFieldNodeSchema,\n\tLeafNodeSchema,\n\tMapNodeSchema,\n\tObjectNodeSchema,\n\tAny,\n\tFields,\n\tFlexListToUnion,\n\tFlexList,\n} from \"../typed-schema\";\nimport { FieldKinds } from \"../default-schema\";\nimport { FieldKind } from \"../modular-schema\";\nimport { EditableTreeEvents } from \"./treeEvents\";\nimport { FlexTreeContext } from \"./context\";\n\n/**\n * Indicates that an object is a flex tree.\n * @internal\n */\nexport const flexTreeMarker = Symbol(\"flexTreeMarker\");\n\nexport function isFlexTreeEntity(t: unknown): t is FlexTreeEntity {\n\treturn typeof t === \"object\" && t !== null && flexTreeMarker in t;\n}\n\nexport function isFlexTreeNode(t: unknown): t is FlexTreeNode {\n\treturn isFlexTreeEntity(t) && t[flexTreeMarker] === FlexTreeEntityKind.Node;\n}\n\n/**\n * @internal\n */\nexport enum FlexTreeEntityKind {\n\tNode,\n\tField,\n}\n\n/**\n * Allows boxed iteration of a tree/field\n */\nexport const boxedIterator = Symbol();\n\n/**\n * Part of a tree.\n * Iterates over children.\n *\n * @privateRemarks\n * This exists mainly as a place to share common members between nodes and fields.\n * It is not expected to be useful or common to write code which handles this type directly.\n * If this assumption turns out to be false, and generically processing `UntypedEntity`s is useful,\n * then this interface should probably be extended with some down casting functionality (like `is`).\n *\n * TODO:\n * Design and document iterator invalidation rules and ordering rules.\n * Providing a custom iterator type with place anchor semantics would be a good approach.\n *\n * @internal\n */\nexport interface FlexTreeEntity<out TSchema = unknown> {\n\t/**\n\t * Indicates that an object is a specific kind of flex tree FlexTreeEntity.\n\t * This makes it possible to both down cast FlexTreeEntities safely as well as validate if an object is or is not a FlexTreeEntity.\n\t */\n\treadonly [flexTreeMarker]: FlexTreeEntityKind;\n\n\t/**\n\t * Schema for this entity.\n\t * If well-formed, it must follow this schema.\n\t */\n\treadonly schema: TSchema;\n\n\t/**\n\t * A common context of a \"forest\" of EditableTrees.\n\t */\n\treadonly context: FlexTreeContext;\n\n\t/**\n\t * Gets the {@link TreeStatus} of this tree.\n\t *\n\t * @remarks\n\t * For non-root fields, this is the status of the parent node, since fields do not have a separate lifetime.\n\t */\n\ttreeStatus(): TreeStatus;\n\n\t/**\n\t * Iterate through all nodes/fields in this field/node.\n\t *\n\t * @remarks\n\t * No mutations to the current view of the shared tree are permitted during iteration.\n\t */\n\t[boxedIterator](): IterableIterator<FlexTreeEntity>;\n}\n\n/**\n * Status of the tree that a particular node belongs to.\n * @beta\n */\nexport enum TreeStatus {\n\t/**\n\t * Is parented under the root field.\n\t */\n\tInDocument = 0,\n\n\t/**\n\t * Is not parented under the root field, but can be added back to the original document tree.\n\t */\n\tRemoved = 1,\n\n\t/**\n\t * Is removed and cannot be added back to the original document tree.\n\t */\n\tDeleted = 2,\n}\n\n/**\n * {@inheritdoc TreeNode.[onNextChange]}\n */\nexport const onNextChange = Symbol(\"onNextChange\");\n\n/**\n * Generic tree node API.\n *\n * Nodes are (shallowly) immutable and have a logical identity, a type and either a value or fields under string keys.\n *\n * This \"logical identity\" is exposed as the object identity: if a node is moved within a document,\n * the same {@link FlexTreeNode} instance will be used in the new location.\n * Similarly, edits applied to a node's sub-tree concurrently with the move of the node will still be applied to its subtree in its new location.\n *\n *\n * @remarks\n * Down-casting (via {@link FlexTreeNode#is}) is required to access Schema-Aware APIs, including editing.\n * All content in the tree is accessible without down-casting, but if the schema is known,\n * the schema aware API may be more ergonomic.\n * All editing is actually done via {@link FlexTreeField}s: the nodes are immutable other than that they contain mutable fields.\n *\n * @internal\n */\nexport interface FlexTreeNode extends FlexTreeEntity<TreeNodeSchema> {\n\treadonly [flexTreeMarker]: FlexTreeEntityKind.Node;\n\n\t/**\n\t * Value stored on this node.\n\t */\n\treadonly value?: TreeValue;\n\n\t/**\n\t * {@inheritDoc ISubscribable#on}\n\t */\n\ton<K extends keyof EditableTreeEvents>(\n\t\teventName: K,\n\t\tlistener: EditableTreeEvents[K],\n\t): () => void;\n\n\t/**\n\t * Gets a field of this node, if it is not empty.\n\t */\n\ttryGetField(key: FieldKey): undefined | FlexTreeField;\n\n\t/**\n\t * The field this tree is in, and the index within that field.\n\t */\n\treadonly parentField: { readonly parent: FlexTreeField; readonly index: number };\n\n\t/**\n\t * Type guard for narrowing / down-casting to a specific schema.\n\t */\n\tis<TSchema extends TreeNodeSchema>(schema: TSchema): this is FlexTreeTypedNode<TSchema>;\n\n\t/**\n\t * Same as `this.schema.name`.\n\t * This is provided as an enumerable own property to aid with JavaScript object traversals of this data-structure.\n\t * See [ReadMe](./README.md) for details.\n\t */\n\treadonly type: TreeNodeSchemaIdentifier;\n\n\t[boxedIterator](): IterableIterator<FlexTreeField>;\n\n\t/**\n\t * Subscribe to the next change that affects this node's children.\n\t * @returns a function which will deregister the registered event.\n\t * It has no effect if the event was already deregistered.\n\t * @remarks\n\t * The given function will be run the next time that this node's direct children change.\n\t * It will only be run once, and thereafter automatically deregistered.\n\t * It does not run in response to changes beneath this node's direct children.\n\t * This event fires after the tree has been mutated but before {@link EditableTreeEvents.afterChange}.\n\t * Only one subscriber may register to this event at the same time.\n\t * @privateRemarks\n\t * This event allows the proxy-based API that is built on top of the editable tree to maintain invariants\n\t * around \"hydrating\" proxies that were created with schema-provided factory functions.\n\t * It is not a public API and thus the symbol for this property is not exported.\n\t */\n\t[onNextChange](fn: (node: FlexTreeNode) => void): () => void;\n}\n\n/**\n * A collaboratively editable collection of nodes within a {@link FlexTreeEntity}.\n *\n * Fields are inherently part of their parent, and thus cannot be moved.\n * Instead their content can be moved, deleted or created.\n *\n * Editing operations are only valid on trees with the {@link TreeStatus#InDocument} `TreeStatus`.\n *\n * @remarks\n * Fields are used wherever an editable collection of nodes is required.\n * This is required in two places:\n * 1. To hold the children of non-leaf {@link FlexTreeNode}s.\n * 2. As the root of a {@link FlexTreeEntity}.\n *\n * Down-casting (via {@link FlexTreeField.is}) is required to access Schema-Aware APIs, including editing.\n * All content in the tree is accessible without down-casting, but if the schema is known,\n * the schema aware API may be more ergonomic.\n *\n * @internal\n */\nexport interface FlexTreeField extends FlexTreeEntity<TreeFieldSchema> {\n\treadonly [flexTreeMarker]: FlexTreeEntityKind.Field;\n\n\t/**\n\t * The `FieldKey` this field is under.\n\t * Defines what part of its parent this field makes up.\n\t */\n\treadonly key: FieldKey;\n\n\t/**\n\t * The node which has this field on it under `fieldKey`.\n\t * `undefined` iff this field is a detached field.\n\t */\n\treadonly parent?: FlexTreeNode;\n\n\t/**\n\t * Type guard for narrowing / down-casting to a specific schema.\n\t */\n\tis<TSchema extends TreeFieldSchema>(schema: TSchema): this is FlexTreeTypedField<TSchema>;\n\n\t[boxedIterator](): IterableIterator<FlexTreeNode>;\n\n\t/**\n\t * Check if this field is the same as a different field.\n\t * This is defined to mean that both are in the same editable tree, and are the same field on the same node.\n\t * This is more than just a reference comparison because unlike EditableTree nodes, fields are not cached on anchors and can be duplicated.\n\t *\n\t * @privateRemarks\n\t * TODO:\n\t * If practical, cache TreeField instances so use of this method can be replaced with `===` to compare object identity.\n\t * Implementing this will require some care to preserve lazy-ness and work efficiently (without leaks) for empty fields, particularly on MapNodes.\n\t */\n\tisSameAs(other: FlexTreeField): boolean;\n}\n\n// #region Node Kinds\n\n/**\n * A {@link FlexTreeNode} that behaves like a `Map<string, Field>` for a specific `Field` type.\n *\n * @remarks\n * Unlike TypeScript Map type, {@link FlexTreeMapNode.get} always provides a reference to any field looked up, even if it has never been set.\n *\n * This means that, for example, a `MapNode` of {@link FlexTreeSequenceField} fields will return an empty sequence when a previously unused key is looked up,\n * and that sequence can be used to insert new items into the field.\n * Additionally empty fields (those containing no nodes) are not distinguished from fields which do not exist.\n * This differs from JavaScript Maps which have a subtle distinction between storing undefined as a value in the map and deleting an entry from the map.\n *\n * @internal\n */\nexport interface FlexTreeMapNode<in out TSchema extends MapNodeSchema> extends FlexTreeNode {\n\treadonly schema: TSchema;\n\n\t/**\n\t * The number of elements in the map.\n\t *\n\t * @remarks\n\t * All fields under a map implicitly exist, but `size` will count only the fields which contain one or more nodes.\n\t */\n\treadonly size: number;\n\n\t/**\n\t * Checks whether a value exists for the given key.\n\t * @param key - Which map entry to look up.\n\t *\n\t * @remarks\n\t * All fields under a map implicitly exist, but `has` will only return true if there are one or more nodes present in the given field.\n\t */\n\thas(key: string): boolean;\n\n\t/**\n\t * Get the value associated with `key`.\n\t * @param key - which map entry to look up.\n\t */\n\tget(key: string): FlexTreeUnboxField<TSchema[\"info\"]>;\n\n\t/**\n\t * Get the field for `key`.\n\t * @param key - which map entry to look up.\n\t *\n\t * @remarks\n\t * All fields under a map implicitly exist, so `get` can be called with any key and will always return a field.\n\t * Even if the field is empty, it will still be returned, and can be edited to insert content into the map.\n\t */\n\tgetBoxed(key: string): FlexTreeTypedField<TSchema[\"info\"]>;\n\n\t/**\n\t * Returns an iterable of keys in the map.\n\t *\n\t * @remarks\n\t * All fields under a map implicitly exist, but `keys` will yield only the keys of fields which contain one or more nodes.\n\t */\n\tkeys(): IterableIterator<FieldKey>;\n\n\t/**\n\t * Returns an iterable of values in the map.\n\t *\n\t * @remarks\n\t * All fields under a map implicitly exist, but `values` will yield only the fields containing one or more nodes.\n\t */\n\tvalues(): IterableIterator<FlexTreeUnboxField<TSchema[\"info\"], \"notEmpty\">>;\n\n\t/**\n\t * Returns an iterable of key, value pairs for every entry in the map.\n\t *\n\t * @remarks\n\t * All fields under a map implicitly exist, but `entries` will yield only the entries whose fields contain one or more nodes.\n\t *\n\t * This iteration provided by `entries()` is equivalent to that provided by direct iteration of the {@link FlexTreeMapNode} (a.k.a. `[Symbol.Iterator]()`).\n\t */\n\tentries(): IterableIterator<[FieldKey, FlexTreeUnboxField<TSchema[\"info\"], \"notEmpty\">]>;\n\n\t/**\n\t * Executes a provided function once per each key/value pair in the map.\n\t * @param callbackFn - The function to run for each map entry\n\t * @param thisArg - If present, `callbackFn` will be bound to `thisArg`\n\t *\n\t * @privateRemarks\n\t * TODO: This should run over fields in insertion order if we want to match the javascript foreach spec.\n\t */\n\tforEach(\n\t\tcallbackFn: (\n\t\t\tvalue: FlexTreeUnboxField<TSchema[\"info\"], \"notEmpty\">,\n\t\t\tkey: FieldKey,\n\t\t\tmap: FlexTreeMapNode<TSchema>,\n\t\t) => void,\n\t\tthisArg?: any,\n\t): void;\n\n\t/**\n\t * Adds or updates an entry in the map with a specified `key` and a `value`.\n\t *\n\t * @param key - The key of the element to add to the map.\n\t * @param value - The value of the element to add to the map.\n\t */\n\tset(key: string, value: FlexibleFieldContent<TSchema[\"info\"]>): void;\n\n\t/**\n\t * Removes the specified element from this map by its `key`.\n\t *\n\t * @remarks\n\t * Note: unlike JavaScript's Map API, this method does not return a flag indicating whether or not the value was\n\t * deleted.\n\t *\n\t * @privateRemarks\n\t * Regarding the choice to not return a boolean: Since this data structure is distributed in nature, it isn't\n\t * possible to tell whether or not the item was deleted as a result of this method call. Returning a \"best guess\"\n\t * is more likely to create issues / promote bad usage patterns than offer useful information.\n\t *\n\t * @param key - The key of the element to remove from the map.\n\t */\n\tdelete(key: string): void;\n\n\t/**\n\t * Iterate through all fields in the map.\n\t *\n\t * @remarks\n\t * No mutations to the current view of the shared tree are permitted during iteration.\n\t * To iterate over the unboxed values of the map, use `Symbol.Iterator()`.\n\t */\n\t[boxedIterator](): IterableIterator<FlexTreeTypedField<TSchema[\"info\"]>>;\n\n\t[Symbol.iterator](): IterableIterator<\n\t\t[FieldKey, FlexTreeUnboxField<TSchema[\"info\"], \"notEmpty\">]\n\t>;\n\n\t/**\n\t * An enumerable own property which allows JavaScript object traversals to access {@link FlexTreeSequenceField} content.\n\t * It is recommenced to NOT use this when possible (for performance and type safety reasons): instead use {@link FlexTreeMapNode.get} or iterate over fields with `Symbol.iterator`.\n\t * See [ReadMe](./README.md) for details.\n\t *\n\t * This object is not guaranteed to be kept up to date across edits and thus should not be held onto across edits.\n\t */\n\treadonly asObject: {\n\t\treadonly [P in FieldKey]?: FlexTreeUnboxField<TSchema[\"info\"], \"notEmpty\">;\n\t};\n}\n\n/**\n * A {@link FlexTreeNode} that wraps a single {@link FlexTreeField} (which is placed under the {@link EmptyKey}).\n *\n * @remarks\n * A FieldNode is mostly identical to a struct node with a single field using the {@link EmptyKey}, but provides access to it via a field named \"content\".\n *\n * There are several use-cases where it makes sense to use a field node.\n * Here are a few:\n * - When it's necessary to differentiate between an empty sequence, and no sequence.\n * One case where this is needed is encoding Json.\n * - When polymorphism over {@link TreeFieldSchema} (and not just a union of {@link AllowedTypes}) is required.\n * For example when encoding a schema for a type like\n * `Foo[] | Bar[]`, `Foo | Foo[]` or `Optional<Foo> | Optional<Bar>` (Where `Optional` is the Optional field kind, not TypeScript's `Optional`).\n * Since this schema system only allows `|` of {@link TreeNodeSchema} (and only when declaring a {@link TreeFieldSchema}), see {@link SchemaBuilderBase.field},\n * these aggregate types are most simply expressed by creating fieldNodes for the terms like `Foo[]`, and `Optional<Foo>`.\n * Note that these are distinct from types like `(Foo | Bar)[]` and `Optional<Foo | Bar>` which can be expressed as single fields without extra nodes.\n * - When a distinct merge identity is desired for a field.\n * For example, if the application wants to be able to have an optional node or a sequence which it can pass around, edit and observe changes to,\n * in some cases (like when the content is moved to a different parent) this can be more flexible if a field node is introduced\n * to create a separate logical entity (node) which wraps the field.\n * This can even be useful with value fields to wrap terminal nodes if a stable merge\n * - When a field (such as a {@link FlexTreeSequenceField}) is desired in a location where {@link FlexTreeNode}s are required\n * (like the member of a union or the child of another {@link FlexTreeField}).\n * This can is typically just a different perspective on one of the above cases.\n * For example:\n * `Sequence<Foo> | Sequence<Bar>` or `OptionalField<Sequence<Foo>>` can't be expressed as simple fields\n * (unlike `Sequence<Foo | Bar>` or `OptionalField<Foo>` which can be done as simple fields).\n * Instead {@link FlexTreeFieldNode}s can be use to achieve something similar, more like:\n * `FieldNode<Sequence<Foo>> | FieldNode<Sequence<Bar>>` or `OptionalField<FieldNode<Sequence<Foo>>>`.\n *\n * @privateRemarks\n * FieldNodes do not unbox to their content, so in schema aware APIs which do unboxing, the FieldNode will NOT be skipped over.\n * This is a change from the old behavior to simplify unboxing and prevent cases where arbitrary deep chains of field nodes could unbox omitting information about the tree depth.\n * @internal\n */\nexport interface FlexTreeFieldNode<in out TSchema extends FieldNodeSchema> extends FlexTreeNode {\n\treadonly schema: TSchema;\n\n\t/**\n\t * The content this field node wraps.\n\t * @remarks\n\t * This is a version of {@link FlexTreeFieldNode.boxedContent} but does unboxing.\n\t * Since field node are usually used to wrap fields which don't do unboxing (like {@link FlexTreeSequenceField})\n\t */\n\treadonly content: FlexTreeUnboxField<TSchema[\"info\"]>;\n\t/**\n\t * The field this field node wraps.\n\t *\n\t * @remarks\n\t * Since field nodes are usually used to wrap fields which don't do unboxing (like {@link FlexTreeSequenceField}),\n\t * this is usually the same as {@link FlexTreeFieldNode.content}.\n\t * This is also the same as `[...this][0]`.\n\t */\n\treadonly boxedContent: FlexTreeTypedField<TSchema[\"info\"]>;\n}\n\n/**\n * A {@link FlexTreeNode} that behaves like an \"object\" or \"struct\", providing properties to access its fields.\n *\n * ObjectNodes consist of a finite collection of fields, each with their own (distinct) key and {@link TreeFieldSchema}.\n *\n * @remarks\n * ObjectNodes require complex typing, and have been split into two parts for implementation purposes.\n * See {@link FlexTreeObjectNodeTyped} for the schema aware extensions to this that provide access to the fields.\n *\n * These \"Objects\" resemble \"Structs\" from a wide variety of programming languages\n * (Including Algol 68, C, Go, Rust, C# etc.).\n * ObjectNodes also somewhat resemble JavaScript objects: this analogy is less precise (objects don't have a fixed schema for example),\n * but for consistency with other systems in the JavaScript ecosystem (like JSON) is \"ObjectNodes\" nodes are named \"Objects\".\n *\n * Another common name for this abstraction is [record](https://en.wikipedia.org/wiki/Record_(computer_science)).\n * The name \"Record\" is avoided (in favor of Object) here because it has less precise connotations for most TypeScript developers.\n * For example, TypeScript has a built in `Record` type, but it requires all of the fields to have the same type,\n * putting its semantics half way between this library's \"Object\" schema and {@link FlexTreeMapNode}.\n *\n * @internal\n */\nexport interface FlexTreeObjectNode extends FlexTreeNode {\n\treadonly schema: ObjectNodeSchema;\n\n\t/**\n\t * {@link LocalNodeKey} that identifies this node.\n\t */\n\treadonly localNodeKey?: LocalNodeKey;\n}\n\n/**\n * Leaf holding a value.\n *\n * @remarks\n * Leaves are immutable and have no children.\n * Leaf unboxes its content, so in schema aware APIs which do unboxing, the Leaf itself will be skipped over and its value will be returned directly.\n * @internal\n */\nexport interface FlexTreeLeafNode<in out TSchema extends LeafNodeSchema> extends FlexTreeNode {\n\treadonly schema: TSchema;\n\n\t/**\n\t * Value stored on this node.\n\t */\n\treadonly value: TreeValue<TSchema[\"info\"]>;\n}\n\n/**\n * An {@link FlexTreeObjectNode} with schema aware accessors for its fields.\n *\n * @privateRemarks\n *\n * The corresponding implementation logic for this lives in `LazyTree.ts` under `buildStructClass`.\n * If you change the signature here, you will need to update that logic to match.\n *\n * @internal\n */\nexport type FlexTreeObjectNodeTyped<TSchema extends ObjectNodeSchema> =\n\tObjectNodeSchema extends TSchema\n\t\t? FlexTreeObjectNode\n\t\t: FlexTreeObjectNode & FlexTreeObjectNodeFields<TSchema[\"info\"]>;\n\n/**\n * Properties to access an object node's fields. See {@link FlexTreeObjectNodeTyped}.\n *\n * @privateRemarks TODOs:\n *\n * 1. Support custom field keys.\n *\n * 2. Do we keep assignment operator + \"setFoo\" methods, or just use methods?\n * Inconsistency in the API experience could confusing for consumers.\n *\n * @internal\n */\nexport type FlexTreeObjectNodeFields<TFields extends Fields> = FlattenKeys<\n\t{\n\t\t// boxed fields (TODO: maybe remove these when same as non-boxed version?)\n\t\treadonly [key in keyof TFields as `boxed${Capitalize<key & string>}`]: FlexTreeTypedField<\n\t\t\tTFields[key]\n\t\t>;\n\t} & {\n\t\t// Add getter only (make property readonly) when the field is **not** of a kind that has a logical set operation.\n\t\t// If we could map to getters and setters separately, we would preferably do that, but we can't.\n\t\t// See https://github.com/microsoft/TypeScript/issues/43826 for more details on this limitation.\n\t\treadonly [key in keyof TFields as TFields[key][\"kind\"] extends AssignableFieldKinds\n\t\t\t? never\n\t\t\t: key]: FlexTreeUnboxField<TFields[key]>;\n\t} & {\n\t\t// Add setter (make property writable) when the field is of a kind that has a logical set operation.\n\t\t// If we could map to getters and setters separately, we would preferably do that, but we can't.\n\t\t// See https://github.com/microsoft/TypeScript/issues/43826 for more details on this limitation.\n\t\t-readonly [key in keyof TFields as TFields[key][\"kind\"] extends AssignableFieldKinds\n\t\t\t? key\n\t\t\t: never]: FlexTreeUnboxField<TFields[key]>;\n\t} & {\n\t\t// Setter method (when the field is of a kind that has a logical set operation).\n\t\treadonly [key in keyof TFields as TFields[key][\"kind\"] extends AssignableFieldKinds\n\t\t\t? `set${Capitalize<key & string>}`\n\t\t\t: never]: (content: FlexibleFieldContent<TFields[key]>) => void;\n\t}\n>;\n\n/**\n * Field kinds that allow value assignment.\n *\n * @internal\n */\nexport type AssignableFieldKinds = typeof FieldKinds.optional | typeof FieldKinds.required;\n\n// #endregion\n\n// #region Field Kinds\n\n/**\n * Strongly typed tree literals for inserting as the content of a field.\n *\n * If a cursor is provided, it must be in Fields mode.\n * @internal\n */\nexport type FlexibleFieldContent<TSchema extends TreeFieldSchema> =\n\t| InsertableFlexField<TSchema>\n\t| ITreeCursorSynchronous;\n\n/**\n * Strongly typed tree literals for inserting as a node.\n *\n * If a cursor is provided, it must be in Nodes mode.\n * @internal\n */\nexport type FlexibleNodeContent<TTypes extends AllowedTypes> =\n\t| AllowedTypesToFlexInsertableTree<TTypes>\n\t| ITreeCursorSynchronous;\n\n/**\n * Strongly typed tree literals for inserting a subsequence of nodes.\n *\n * Used to insert a batch of 0 or more nodes into some location in a {@link FlexTreeSequenceField}.\n *\n * If a cursor is provided, it must be in Fields mode.\n * @internal\n */\nexport type FlexibleNodeSubSequence<TTypes extends AllowedTypes> =\n\t| Iterable<AllowedTypesToFlexInsertableTree<TTypes>>\n\t| ITreeCursorSynchronous;\n\n/**\n * Type to ensures two types overlap in at least one way.\n * It evaluates to the input type if this is true, and never otherwise.\n * Examples:\n * CheckTypesOverlap\\<number | boolean, number | object\\> = number | boolean\n * CheckTypesOverlap\\<number | boolean, string | object\\> = never\n * @internal\n */\nexport type CheckTypesOverlap<T, TCheck> = [Extract<T, TCheck> extends never ? never : T][0];\n\n/**\n * {@link FlexTreeField} that stores a sequence of children.\n *\n * Sequence fields can contain an ordered sequence any number of {@link FlexTreeNode}s which must be of the {@link AllowedTypes} from the {@link TreeFieldSchema}).\n *\n * @remarks\n * Allows for concurrent editing based on index, adjusting the locations of indexes as needed so they apply to the same logical place in the sequence when rebased and merged.\n *\n * Edits to sequence fields are anchored relative to their surroundings, so concurrent edits can result in the indexes of nodes and edits getting shifted.\n * To hold onto locations in sequence across an edit, use anchors.\n *\n * @privateRemarks\n * TODO:\n * Add anchor API that can actually hold onto locations in a sequence.\n * Currently only nodes can be held onto with anchors, and this does not replicate the behavior implemented for editing.\n * @internal\n */\nexport interface FlexTreeSequenceField<in out TTypes extends AllowedTypes> extends FlexTreeField {\n\t/**\n\t * Gets a node of this field by its index with unboxing.\n\t * @param index - Zero-based index of the item to retrieve. Negative values are interpreted from the end of the sequence.\n\t *\n\t * @returns The element in the sequence matching the given index. Always returns undefined if index \\< -sequence.length\n\t * or index \\>= array.length.\n\t *\n\t * @remarks\n\t * Semantics match {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at}.\n\t */\n\tat(index: number): FlexTreeUnboxNodeUnion<TTypes> | undefined;\n\n\t/**\n\t * Gets a node of this field by its index without unboxing.\n\t * @param index - Zero-based index of the item to retrieve. Negative values are interpreted from the end of the sequence.\n\t *\n\t * @returns The element in the sequence matching the given index. Always returns undefined if index \\< -sequence.length\n\t * or index \\>= array.length.\n\t *\n\t * @remarks\n\t * Semantics match {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at}.\n\t */\n\tboxedAt(index: number): FlexTreeTypedNodeUnion<TTypes> | undefined;\n\n\t/**\n\t * Calls the provided callback function on each child of this sequence, and returns an array that contains the results.\n\t * @param callbackfn - A function that accepts the child and its index.\n\t */\n\tmap<U>(callbackfn: (value: FlexTreeUnboxNodeUnion<TTypes>, index: number) => U): U[];\n\n\t/**\n\t * Calls the provided callback function on each child of this sequence, and returns an array that contains the results.\n\t * @param callbackfn - A function that accepts the child and its index.\n\t */\n\tmapBoxed<U>(callbackfn: (value: FlexTreeTypedNodeUnion<TTypes>, index: number) => U): U[];\n\n\treadonly length: number;\n\n\t/**\n\t * Inserts new item(s) at a specified location.\n\t * @param index - The index at which to insert `value`.\n\t * @param value - The content to insert.\n\t * @throws Throws if `index` is not in the range [0, `list.length`).\n\t */\n\tinsertAt(index: number, value: FlexibleNodeSubSequence<TTypes>): void;\n\n\t/**\n\t * Inserts new item(s) at the start of the sequence.\n\t * @param value - The content to insert.\n\t */\n\tinsertAtStart(value: FlexibleNodeSubSequence<TTypes>): void;\n\n\t/**\n\t * Inserts new item(s) at the end of the sequence.\n\t * @param value - The content to insert.\n\t */\n\tinsertAtEnd(value: FlexibleNodeSubSequence<TTypes>): void;\n\n\t/**\n\t * Removes the item at the specified location.\n\t * @param index - The index at which to remove the item.\n\t * @throws Throws if `index` is not in the range [0, `list.length`).\n\t */\n\tremoveAt(index: number): void;\n\n\t/**\n\t * Removes all items between the specified indices.\n\t * @param start - The starting index of the range to remove (inclusive). Defaults to the start of the sequence.\n\t * @param end - The ending index of the range to remove (exclusive).\n\t * @throws Throws if `start` is not in the range [0, `list.length`).\n\t * @throws Throws if `end` is less than `start`.\n\t * If `end` is not supplied or is greater than the length of the sequence, all items after `start` are deleted.\n\t */\n\tremoveRange(start?: number, end?: number): void;\n\n\t/**\n\t * Moves the specified item to the start of the sequence.\n\t * @param sourceIndex - The index of the item to move.\n\t * @throws Throws if `sourceIndex` is not in the range [0, `list.length`).\n\t */\n\tmoveToStart(sourceIndex: number): void;\n\n\t/**\n\t * Moves the specified item to the start of the sequence.\n\t * @param sourceIndex - The index of the item to move.\n\t * @param source - The source sequence to move the item out of.\n\t * @throws Throws if `sourceIndex` is not in the range [0, `list.length`).\n\t */\n\tmoveToStart(sourceIndex: number, source: FlexTreeSequenceField<AllowedTypes>): void;\n\n\t/**\n\t * Moves the specified item to the end of the sequence.\n\t * @param sourceIndex - The index of the item to move.\n\t * @throws Throws if `sourceIndex` is not in the range [0, `list.length`).\n\t */\n\tmoveToEnd(sourceIndex: number): void;\n\n\t/**\n\t * Moves the specified item to the end of the sequence.\n\t * @param sourceIndex - The index of the item to move.\n\t * @param source - The source sequence to move the item out of.\n\t * @throws Throws if `sourceIndex` is not in the range [0, `list.length`).\n\t */\n\tmoveToEnd(sourceIndex: number, source: FlexTreeSequenceField<AllowedTypes>): void;\n\n\t/**\n\t * Moves the specified item to the desired location in the sequence.\n\t * @param index - The index to move the item to.\n\t * This is based on the state of the sequence before moving the source item.\n\t * @param sourceIndex - The index of the item to move.\n\t * @throws Throws if any of the input indices are not in the range [0, `list.length`).\n\t */\n\tmoveToIndex(index: number, sourceIndex: number): void;\n\n\t/**\n\t * Moves the specified item to the desired location in the sequence.\n\t * @param index - The index to move the item to.\n\t * @param sourceIndex - The index of the item to move.\n\t * @param source - The source sequence to move the item out of.\n\t * @throws Throws if any of the input indices are not in the range [0, `list.length`).\n\t */\n\tmoveToIndex(\n\t\tindex: number,\n\t\tsourceIndex: number,\n\t\tsource: FlexTreeSequenceField<AllowedTypes>,\n\t): void;\n\n\t/**\n\t * Moves the specified items to the start of the sequence.\n\t * @param sourceStart - The starting index of the range to move (inclusive).\n\t * @param sourceEnd - The ending index of the range to move (exclusive)\n\t * @throws Throws if either of the input indices are not in the range [0, `list.length`) or if `sourceStart` is greater than `sourceEnd`.\n\t */\n\tmoveRangeToStart(sourceStart: number, sourceEnd: number): void;\n\n\t/**\n\t * Moves the specified items to the start of the sequence.\n\t * @param sourceStart - The starting index of the range to move (inclusive).\n\t * @param sourceEnd - The ending index of the range to move (exclusive)\n\t * @param source - The source sequence to move items out of.\n\t * @throws Throws if the types of any of the items being moved are not allowed in the destination sequence,\n\t * if either of the input indices are not in the range [0, `list.length`) or if `sourceStart` is greater than `sourceEnd`.\n\t */\n\tmoveRangeToStart(\n\t\tsourceStart: number,\n\t\tsourceEnd: number,\n\t\tsource: FlexTreeSequenceField<AllowedTypes>,\n\t): void;\n\n\t/**\n\t * Moves the specified items to the end of the sequence.\n\t * @param sourceStart - The starting index of the range to move (inclusive).\n\t * @param sourceEnd - The ending index of the range to move (exclusive)\n\t * @throws Throws if either of the input indices are not in the range [0, `list.length`) or if `sourceStart` is greater than `sourceEnd`.\n\t */\n\tmoveRangeToEnd(sourceStart: number, sourceEnd: number): void;\n\n\t/**\n\t * Moves the specified items to the end of the sequence.\n\t * @param sourceStart - The starting index of the range to move (inclusive).\n\t * @param sourceEnd - The ending index of the range to move (exclusive)\n\t * @param source - The source sequence to move items out of.\n\t * @throws Throws if the types of any of the items being moved are not allowed in the destination sequence,\n\t * if either of the input indices are not in the range [0, `list.length`) or if `sourceStart` is greater than `sourceEnd`.\n\t */\n\tmoveRangeToEnd(\n\t\tsourceStart: number,\n\t\tsourceEnd: number,\n\t\tsource: FlexTreeSequenceField<AllowedTypes>,\n\t): void;\n\n\t/**\n\t * Moves the specified items to the desired location within the sequence.\n\t * @param index - The index to move the items to.\n\t * This is based on the state of the sequence before moving the source items.\n\t * @param sourceStart - The starting index of the range to move (inclusive).\n\t * @param sourceEnd - The ending index of the range to move (exclusive)\n\t * @throws Throws if any of the input indices are not in the range [0, `list.length`) or if `sourceStart` is greater than `sourceEnd`.\n\t */\n\tmoveRangeToIndex(index: number, sourceStart: number, sourceEnd: number): void;\n\n\t/**\n\t * Moves the specified items to the desired location within the sequence.\n\t * @param index - The index to move the items to.\n\t * @param sourceStart - The starting index of the range to move (inclusive).\n\t * @param sourceEnd - The ending index of the range to move (exclusive)\n\t * @param source - The source sequence to move items out of.\n\t * @throws Throws if the types of any of the items being moved are not allowed in the destination sequence,\n\t * if any of the input indices are not in the range [0, `list.length`) or if `sourceStart` is greater than `sourceEnd`.\n\t */\n\tmoveRangeToIndex(\n\t\tindex: number,\n\t\tsourceStart: number,\n\t\tsourceEnd: number,\n\t\tsource: FlexTreeSequenceField<AllowedTypes>,\n\t): void;\n\n\t[boxedIterator](): IterableIterator<FlexTreeTypedNodeUnion<TTypes>>;\n\n\t[Symbol.iterator](): IterableIterator<FlexTreeUnboxNodeUnion<TTypes>>;\n\n\t/**\n\t * An enumerable own property which allows JavaScript object traversals to access {@link FlexTreeSequenceField} content.\n\t * It is recommenced to NOT use this when possible (for performance and type safety reasons): instead use {@link FlexTreeSequenceField#at} or iterate over nodes with `Symbol.iterator`.\n\t * See [ReadMe](./README.md) for details.\n\t *\n\t * This array is not guaranteed to be kept up to date across edits and thus should not be held onto across edits.\n\t */\n\treadonly asArray: readonly FlexTreeUnboxNodeUnion<TTypes>[];\n}\n\n/**\n * Field that stores exactly one child.\n *\n * @remarks\n * Unboxes its content, so in schema aware APIs which do unboxing, the RequiredField itself will be skipped over and its content will be returned directly.\n * @internal\n */\nexport interface FlexTreeRequiredField<in out TTypes extends AllowedTypes> extends FlexTreeField {\n\tget content(): FlexTreeUnboxNodeUnion<TTypes>;\n\tset content(content: FlexibleNodeContent<TTypes>);\n\n\treadonly boxedContent: FlexTreeTypedNodeUnion<TTypes>;\n}\n\n/**\n * Field that stores zero or one child.\n *\n * @remarks\n * Unboxes its content, so in schema aware APIs which do unboxing, the OptionalField itself will be skipped over and its content will be returned directly.\n *\n * @privateRemarks\n * TODO: Document merge semitics\n * TODO: Allow Optional fields to be used with last write wins OR first write wins merge resolution.\n * TODO:\n * Better centralize the documentation about what kinds of merge semantics are available for field kinds.\n * Maybe link editor?\n * @internal\n */\nexport interface FlexTreeOptionalField<in out TTypes extends AllowedTypes> extends FlexTreeField {\n\tget content(): FlexTreeUnboxNodeUnion<TTypes> | undefined;\n\tset content(newContent: FlexibleNodeContent<TTypes> | undefined);\n\n\treadonly boxedContent?: FlexTreeTypedNodeUnion<TTypes>;\n}\n\n/**\n * Field that contains an immutable {@link StableNodeKey} identifying this node.\n * @internal\n */\nexport interface FlexTreeNodeKeyField extends FlexTreeField {\n\treadonly localNodeKey: LocalNodeKey;\n\treadonly stableNodeKey: StableNodeKey;\n}\n\n// #endregion\n\n// #region Typed\n\n/**\n * Schema aware specialization of {@link FlexTreeField}.\n * @internal\n */\nexport type FlexTreeTypedField<TSchema extends TreeFieldSchema> = FlexTreeTypedFieldInner<\n\tTSchema[\"kind\"],\n\tTSchema[\"allowedTypes\"]\n>;\n\n/**\n * Helper for implementing {@link FlexTreeTypedField}.\n * @internal\n */\nexport type FlexTreeTypedFieldInner<\n\tKind extends FieldKind,\n\tTypes extends AllowedTypes,\n> = Kind extends typeof FieldKinds.sequence\n\t? FlexTreeSequenceField<Types>\n\t: Kind extends typeof FieldKinds.required\n\t? FlexTreeRequiredField<Types>\n\t: Kind extends typeof FieldKinds.optional\n\t? FlexTreeOptionalField<Types>\n\t: Kind extends typeof FieldKinds.nodeKey\n\t? FlexTreeNodeKeyField\n\t: FlexTreeField;\n\n/**\n * Schema aware specialization of {@link FlexTreeNode} for a given {@link AllowedTypes}.\n * @internal\n */\nexport type FlexTreeTypedNodeUnion<T extends AllowedTypes> = T extends FlexList<TreeNodeSchema>\n\t? FlexTreeTypedNode<Assume<FlexListToUnion<T>, TreeNodeSchema>>\n\t: FlexTreeNode;\n\n/**\n * Schema aware specialization of {@link FlexTreeNode} for a given {@link TreeNodeSchema}.\n * @internal\n */\nexport type FlexTreeTypedNode<TSchema extends TreeNodeSchema> = TSchema extends LeafNodeSchema\n\t? FlexTreeLeafNode<TSchema>\n\t: TSchema extends MapNodeSchema\n\t? FlexTreeMapNode<TSchema>\n\t: TSchema extends FieldNodeSchema\n\t? FlexTreeFieldNode<TSchema>\n\t: TSchema extends ObjectNodeSchema\n\t? FlexTreeObjectNodeTyped<TSchema>\n\t: FlexTreeNode;\n\n// #endregion\n\n// #region Unbox\n\n/**\n * Schema aware unboxed field.\n * @remarks\n * Unboxes fields to their content if appropriate for the kind.\n * Recursively unboxes that content (then its content etc.) as well if the node union does unboxing.\n * @internal\n */\nexport type FlexTreeUnboxField<\n\tTSchema extends TreeFieldSchema,\n\t// If \"notEmpty\", then optional fields will unbox to their content (not their content | undefined)\n\tEmptiness extends \"maybeEmpty\" | \"notEmpty\" = \"maybeEmpty\",\n> = FlexTreeUnboxFieldInner<TSchema[\"kind\"], TSchema[\"allowedTypes\"], Emptiness>;\n\n/**\n * Helper for implementing FlexTreeUnboxField.\n * @internal\n */\nexport type FlexTreeUnboxFieldInner<\n\tKind extends FieldKind,\n\tTTypes extends AllowedTypes,\n\tEmptiness extends \"maybeEmpty\" | \"notEmpty\",\n> = Kind extends typeof FieldKinds.sequence\n\t? FlexTreeSequenceField<TTypes>\n\t: Kind extends typeof FieldKinds.required\n\t? FlexTreeUnboxNodeUnion<TTypes>\n\t: Kind extends typeof FieldKinds.optional\n\t? FlexTreeUnboxNodeUnion<TTypes> | (Emptiness extends \"notEmpty\" ? never : undefined)\n\t: // Since struct already provides a short-hand accessor for the local field key, and the field provides a nicer general API than the node under it in this case, do not unbox nodeKey fields.\n\tKind extends typeof FieldKinds.nodeKey\n\t? FlexTreeNodeKeyField\n\t: // TODO: forbidden\n\t  unknown;\n\n/**\n * Schema aware unboxed union of tree types.\n * @remarks\n * Unboxes when not polymorphic.\n * Recursively unboxes that content as well if the node kind does unboxing.\n * @internal\n */\nexport type FlexTreeUnboxNodeUnion<TTypes extends AllowedTypes> = TTypes extends readonly [\n\tInternalTypedSchemaTypes.LazyItem<infer InnerType>,\n]\n\t? InnerType extends TreeNodeSchema\n\t\t? FlexTreeUnboxNode<InnerType>\n\t\t: InnerType extends Any\n\t\t? FlexTreeNode\n\t\t: // This case should not occur. If the result ever ends up unknown, look at places like this to debug.\n\t\t  unknown\n\t: boolean extends IsArrayOfOne<TTypes>\n\t? FlexTreeUnknownUnboxed // Unknown if this will unbox. This should mainly happen when TTypes is AllowedTypes.\n\t: FlexTreeTypedNodeUnion<TTypes>; // Known to not be a single type, so known not to unbox.\n\n/**\n * `true` if T is known to be an array of one item.\n * `false` if T is known not to be an array of one item.\n * `boolean` if it is unknown if T is an array of one item or not.\n * @internal\n */\nexport type IsArrayOfOne<T extends readonly unknown[]> = T[\"length\"] extends 1\n\t? true\n\t: 1 extends T[\"length\"]\n\t? boolean\n\t: false;\n\n/**\n * Schema aware unboxed tree type.\n * @remarks\n * Unboxes if the node kind does unboxing.\n * Recursively unboxes that content as well if it does unboxing.\n * @internal\n */\nexport type FlexTreeUnboxNode<TSchema extends TreeNodeSchema> = TSchema extends LeafNodeSchema\n\t? TreeValue<TSchema[\"info\"]>\n\t: TSchema extends MapNodeSchema\n\t? FlexTreeMapNode<TSchema>\n\t: TSchema extends FieldNodeSchema\n\t? FlexTreeFieldNode<TSchema>\n\t: TSchema extends ObjectNodeSchema\n\t? FlexTreeObjectNodeTyped<TSchema>\n\t: FlexTreeUnknownUnboxed;\n\n/**\n * Unboxed tree type for unknown schema cases.\n * @internal\n */\nexport type FlexTreeUnknownUnboxed = TreeValue | FlexTreeNode;\n\n// #endregion\n"]}

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

@@ -0,0 +1,11 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { FlexTreeField, FlexTreeNode, FlexTreeEntity, FlexTreeTypedField, FlexTreeFieldNode, FlexibleFieldContent, FlexibleNodeContent, FlexTreeLeafNode, FlexTreeMapNode, FlexTreeOptionalField, FlexTreeRequiredField, FlexTreeSequenceField, FlexTreeObjectNode, FlexTreeObjectNodeTyped, AssignableFieldKinds, FlexTreeTypedNode, FlexTreeTypedNodeUnion, boxedIterator, CheckTypesOverlap, TreeStatus, onNextChange, FlexTreeUnknownUnboxed, FlexTreeUnboxField, flexTreeMarker, FlexTreeEntityKind, isFlexTreeNode, } from "./flexTreeTypes";
+export { visitBipartiteIterableTree, Skip, visitBipartiteIterableTreeWithState, visitIterableTree, visitIterableTreeWithState, } from "./navigation";
+export { getTreeContext, FlexTreeContext, Context } from "./context";
+export { TreeEvent, EditableTreeEvents } from "./treeEvents";
+export { FlexTreeTypedFieldInner, FlexTreeUnboxFieldInner, FlexTreeObjectNodeFields, FlexTreeUnboxNode, FlexTreeUnboxNodeUnion, FlexTreeNodeKeyField, IsArrayOfOne, FlexibleNodeSubSequence, } from "./flexTreeTypes";
+export { NodeKeys } from "./nodeKeys";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,aAAa,EACb,YAAY,EACZ,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACpB,iBAAiB,EACjB,sBAAsB,EACtB,aAAa,EACb,iBAAiB,EACjB,UAAU,EACV,YAAY,EACZ,sBAAsB,EACtB,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,cAAc,GACd,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACN,0BAA0B,EAC1B,IAAI,EACJ,mCAAmC,EACnC,iBAAiB,EACjB,0BAA0B,GAC1B,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAErE,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAG7D,OAAO,EACN,uBAAuB,EACvB,uBAAuB,EACvB,wBAAwB,EACxB,iBAAiB,EACjB,sBAAsB,EACtB,oBAAoB,EACpB,YAAY,EACZ,uBAAuB,GACvB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

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

@@ -0,0 +1,24 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = exports.getTreeContext = exports.visitIterableTreeWithState = exports.visitIterableTree = exports.visitBipartiteIterableTreeWithState = exports.Skip = exports.visitBipartiteIterableTree = exports.isFlexTreeNode = exports.FlexTreeEntityKind = exports.flexTreeMarker = exports.onNextChange = exports.TreeStatus = exports.boxedIterator = void 0;
+var flexTreeTypes_1 = require("./flexTreeTypes");
+Object.defineProperty(exports, "boxedIterator", { enumerable: true, get: function () { return flexTreeTypes_1.boxedIterator; } });
+Object.defineProperty(exports, "TreeStatus", { enumerable: true, get: function () { return flexTreeTypes_1.TreeStatus; } });
+Object.defineProperty(exports, "onNextChange", { enumerable: true, get: function () { return flexTreeTypes_1.onNextChange; } });
+Object.defineProperty(exports, "flexTreeMarker", { enumerable: true, get: function () { return flexTreeTypes_1.flexTreeMarker; } });
+Object.defineProperty(exports, "FlexTreeEntityKind", { enumerable: true, get: function () { return flexTreeTypes_1.FlexTreeEntityKind; } });
+Object.defineProperty(exports, "isFlexTreeNode", { enumerable: true, get: function () { return flexTreeTypes_1.isFlexTreeNode; } });
+var navigation_1 = require("./navigation");
+Object.defineProperty(exports, "visitBipartiteIterableTree", { enumerable: true, get: function () { return navigation_1.visitBipartiteIterableTree; } });
+Object.defineProperty(exports, "Skip", { enumerable: true, get: function () { return navigation_1.Skip; } });
+Object.defineProperty(exports, "visitBipartiteIterableTreeWithState", { enumerable: true, get: function () { return navigation_1.visitBipartiteIterableTreeWithState; } });
+Object.defineProperty(exports, "visitIterableTree", { enumerable: true, get: function () { return navigation_1.visitIterableTree; } });
+Object.defineProperty(exports, "visitIterableTreeWithState", { enumerable: true, get: function () { return navigation_1.visitIterableTreeWithState; } });
+var context_1 = require("./context");
+Object.defineProperty(exports, "getTreeContext", { enumerable: true, get: function () { return context_1.getTreeContext; } });
+Object.defineProperty(exports, "Context", { enumerable: true, get: function () { return context_1.Context; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,iDA2ByB;AATxB,8GAAA,aAAa,OAAA;AAEb,2GAAA,UAAU,OAAA;AACV,6GAAA,YAAY,OAAA;AAGZ,+GAAA,cAAc,OAAA;AACd,mHAAA,kBAAkB,OAAA;AAClB,+GAAA,cAAc,OAAA;AAGf,2CAMsB;AALrB,wHAAA,0BAA0B,OAAA;AAC1B,kGAAA,IAAI,OAAA;AACJ,iIAAA,mCAAmC,OAAA;AACnC,+GAAA,iBAAiB,OAAA;AACjB,wHAAA,0BAA0B,OAAA;AAG3B,qCAAqE;AAA5D,yGAAA,cAAc,OAAA;AAAmB,kGAAA,OAAO,OAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport {\n\tFlexTreeField,\n\tFlexTreeNode,\n\tFlexTreeEntity,\n\tFlexTreeTypedField,\n\tFlexTreeFieldNode,\n\tFlexibleFieldContent,\n\tFlexibleNodeContent,\n\tFlexTreeLeafNode,\n\tFlexTreeMapNode,\n\tFlexTreeOptionalField,\n\tFlexTreeRequiredField,\n\tFlexTreeSequenceField,\n\tFlexTreeObjectNode,\n\tFlexTreeObjectNodeTyped,\n\tAssignableFieldKinds,\n\tFlexTreeTypedNode,\n\tFlexTreeTypedNodeUnion,\n\tboxedIterator,\n\tCheckTypesOverlap,\n\tTreeStatus,\n\tonNextChange,\n\tFlexTreeUnknownUnboxed,\n\tFlexTreeUnboxField,\n\tflexTreeMarker,\n\tFlexTreeEntityKind,\n\tisFlexTreeNode,\n} from \"./flexTreeTypes\";\n\nexport {\n\tvisitBipartiteIterableTree,\n\tSkip,\n\tvisitBipartiteIterableTreeWithState,\n\tvisitIterableTree,\n\tvisitIterableTreeWithState,\n} from \"./navigation\";\n\nexport { getTreeContext, FlexTreeContext, Context } from \"./context\";\n\nexport { TreeEvent, EditableTreeEvents } from \"./treeEvents\";\n\n// Below here are things that are used by the above, but not part of the desired API surface.\nexport {\n\tFlexTreeTypedFieldInner,\n\tFlexTreeUnboxFieldInner,\n\tFlexTreeObjectNodeFields,\n\tFlexTreeUnboxNode,\n\tFlexTreeUnboxNodeUnion,\n\tFlexTreeNodeKeyField,\n\tIsArrayOfOne,\n\tFlexibleNodeSubSequence,\n} from \"./flexTreeTypes\";\n\nexport { NodeKeys } from \"./nodeKeys\";\n"]}

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

@@ -0,0 +1,49 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { TreeNavigationResult, ITreeSubscriptionCursor } from "../../core";
+import { disposeSymbol, IDisposable } from "../../util";
+import { Context } from "./context";
+import { FlexTreeEntity, FlexTreeEntityKind, TreeStatus, boxedIterator, flexTreeMarker } from "./flexTreeTypes";
+/**
+ * Declare an enumerable own property on `T` under the key `key` using the implementation of one on `from`.
+ */
+export declare function makePropertyEnumerableOwn<T extends object>(target: T, key: keyof T, from: object): void;
+/**
+ * Modify a property on `T` under the key `key` to be not-enumerable
+ */
+export declare function makePropertyNotEnumerable<T extends object>(target: T, key: keyof T): void;
+/**
+ * Like {@link makePropertyNotEnumerable}, but less type safe so it works on private properties.
+ */
+export declare function makePrivatePropertyNotEnumerable(target: object, key: string | symbol | number): void;
+export declare const prepareForEditSymbol: unique symbol;
+export declare const isFreedSymbol: unique symbol;
+export declare const tryMoveCursorToAnchorSymbol: unique symbol;
+export declare const forgetAnchorSymbol: unique symbol;
+export declare const cursorSymbol: unique symbol;
+export declare const anchorSymbol: unique symbol;
+/**
+ * This is a base class for lazy (cursor based) UntypedEntity implementations, which uniformly handles cursors and anchors.
+ */
+export declare abstract class LazyEntity<TSchema = unknown, TAnchor = unknown> implements FlexTreeEntity<TSchema>, IDisposable {
+    #private;
+    readonly context: Context;
+    readonly schema: TSchema;
+    readonly [anchorSymbol]: TAnchor;
+    protected constructor(context: Context, schema: TSchema, cursor: ITreeSubscriptionCursor, anchor: TAnchor);
+    abstract [boxedIterator](): IterableIterator<FlexTreeEntity>;
+    abstract get [flexTreeMarker](): FlexTreeEntityKind;
+    abstract treeStatus(): TreeStatus;
+    [disposeSymbol](): void;
+    [prepareForEditSymbol](): void;
+    [isFreedSymbol](): boolean;
+    get [cursorSymbol](): ITreeSubscriptionCursor;
+    protected abstract [tryMoveCursorToAnchorSymbol](anchor: TAnchor, cursor: ITreeSubscriptionCursor): TreeNavigationResult;
+    /**
+     * Called when disposing of this target, iff it has an anchor.
+     */
+    protected abstract [forgetAnchorSymbol](anchor: TAnchor): void;
+}
+//# sourceMappingURL=lazyEntity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lazyEntity.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/lazyEntity.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACN,oBAAoB,EACpB,uBAAuB,EAEvB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAQ,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EACN,cAAc,EACd,kBAAkB,EAClB,UAAU,EACV,aAAa,EACb,cAAc,EACd,MAAM,iBAAiB,CAAC;AAEzB;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,MAAM,EACzD,MAAM,EAAE,CAAC,EACT,GAAG,EAAE,MAAM,CAAC,EACZ,IAAI,EAAE,MAAM,GACV,IAAI,CAQN;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,IAAI,CAEzF;AAED;;GAEG;AACH,wBAAgB,gCAAgC,CAC/C,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAC3B,IAAI,CAMN;AAED,eAAO,MAAM,oBAAoB,eAA2B,CAAC;AAC7D,eAAO,MAAM,aAAa,eAAoB,CAAC;AAC/C,eAAO,MAAM,2BAA2B,eAAkC,CAAC;AAC3E,eAAO,MAAM,kBAAkB,eAAyB,CAAC;AACzD,eAAO,MAAM,YAAY,eAAmB,CAAC;AAC7C,eAAO,MAAM,YAAY,eAAmB,CAAC;AAE7C;;GAEG;AACH,8BAAsB,UAAU,CAAC,OAAO,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,CACpE,YAAW,cAAc,CAAC,OAAO,CAAC,EAAE,WAAW;;aAM9B,OAAO,EAAE,OAAO;aAChB,MAAM,EAAE,OAAO;IAJhC,SAAgB,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAExC,SAAS,aACQ,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,OAAO,EAC/B,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,OAAO;aAaA,CAAC,aAAa,CAAC,IAAI,gBAAgB,CAAC,cAAc,CAAC;IACnE,aAAoB,CAAC,cAAc,CAAC,IAAI,kBAAkB,CAAC;aAE3C,UAAU,IAAI,UAAU;IAEjC,CAAC,aAAa,CAAC,IAAI,IAAI;IAOvB,CAAC,oBAAoB,CAAC,IAAI,IAAI;IAK9B,CAAC,aAAa,CAAC,IAAI,OAAO;IAIjC,IAAW,CAAC,YAAY,CAAC,IAAI,uBAAuB,CAkBnD;IAED,SAAS,CAAC,QAAQ,CAAC,CAAC,2BAA2B,CAAC,CAC/C,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,uBAAuB,GAC7B,oBAAoB;IAEvB;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,CAAC,kBAAkB,CAAC,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;CAC9D"}

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

@@ -0,0 +1,104 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LazyEntity_lazyCursor;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyEntity = exports.anchorSymbol = exports.cursorSymbol = exports.forgetAnchorSymbol = exports.tryMoveCursorToAnchorSymbol = exports.isFreedSymbol = exports.prepareForEditSymbol = exports.makePrivatePropertyNotEnumerable = exports.makePropertyNotEnumerable = exports.makePropertyEnumerableOwn = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const core_1 = require("../../core");
+const util_1 = require("../../util");
+const flexTreeTypes_1 = require("./flexTreeTypes");
+/**
+ * Declare an enumerable own property on `T` under the key `key` using the implementation of one on `from`.
+ */
+function makePropertyEnumerableOwn(target, key, from) {
+    (0, core_utils_1.assert)(Object.getOwnPropertyDescriptor(target, key) === undefined, 0x776 /* preexisting property */);
+    const descriptor = Object.getOwnPropertyDescriptor(from, key) ?? (0, util_1.fail)("missing property");
+    Object.defineProperty(target, key, { ...descriptor, enumerable: true });
+}
+exports.makePropertyEnumerableOwn = makePropertyEnumerableOwn;
+/**
+ * Modify a property on `T` under the key `key` to be not-enumerable
+ */
+function makePropertyNotEnumerable(target, key) {
+    makePrivatePropertyNotEnumerable(target, key);
+}
+exports.makePropertyNotEnumerable = makePropertyNotEnumerable;
+/**
+ * Like {@link makePropertyNotEnumerable}, but less type safe so it works on private properties.
+ */
+function makePrivatePropertyNotEnumerable(target, key) {
+    (0, core_utils_1.assert)(Object.getOwnPropertyDescriptor(target, key)?.enumerable === true, 0x777 /* missing property or not enumerable */);
+    Object.defineProperty(target, key, { enumerable: false });
+}
+exports.makePrivatePropertyNotEnumerable = makePrivatePropertyNotEnumerable;
+exports.prepareForEditSymbol = Symbol("prepareForEdit");
+exports.isFreedSymbol = Symbol("isFreed");
+exports.tryMoveCursorToAnchorSymbol = Symbol("tryMoveCursorToAnchor");
+exports.forgetAnchorSymbol = Symbol("forgetAnchor");
+exports.cursorSymbol = Symbol("cursor");
+exports.anchorSymbol = Symbol("anchor");
+/**
+ * This is a base class for lazy (cursor based) UntypedEntity implementations, which uniformly handles cursors and anchors.
+ */
+class LazyEntity {
+    constructor(context, schema, cursor, anchor) {
+        this.context = context;
+        this.schema = schema;
+        _LazyEntity_lazyCursor.set(this, void 0);
+        this[exports.anchorSymbol] = anchor;
+        __classPrivateFieldSet(this, _LazyEntity_lazyCursor, cursor.fork(), "f");
+        context.withCursors.add(this);
+        this.context.withAnchors.add(this);
+        // Setup JS Object API:
+        makePropertyNotEnumerable(this, "context");
+        makePropertyNotEnumerable(this, "schema");
+        makePropertyNotEnumerable(this, exports.anchorSymbol);
+    }
+    [(_LazyEntity_lazyCursor = new WeakMap(), util_1.disposeSymbol)]() {
+        __classPrivateFieldGet(this, _LazyEntity_lazyCursor, "f").free();
+        this.context.withCursors.delete(this);
+        this[exports.forgetAnchorSymbol](this[exports.anchorSymbol]);
+        this.context.withAnchors.delete(this);
+    }
+    [exports.prepareForEditSymbol]() {
+        __classPrivateFieldGet(this, _LazyEntity_lazyCursor, "f").clear();
+        this.context.withCursors.delete(this);
+    }
+    [exports.isFreedSymbol]() {
+        return __classPrivateFieldGet(this, _LazyEntity_lazyCursor, "f").state === core_1.ITreeSubscriptionCursorState.Freed;
+    }
+    get [exports.cursorSymbol]() {
+        if (__classPrivateFieldGet(this, _LazyEntity_lazyCursor, "f").state !== core_1.ITreeSubscriptionCursorState.Current) {
+            (0, core_utils_1.assert)(__classPrivateFieldGet(this, _LazyEntity_lazyCursor, "f").state === core_1.ITreeSubscriptionCursorState.Cleared, 0x778 /* Unset cursor should be in cleared state */);
+            (0, core_utils_1.assert)(this[exports.anchorSymbol] !== undefined, 0x779 /* EditableTree should have an anchor if it does not have a cursor */);
+            const result = this[exports.tryMoveCursorToAnchorSymbol](this[exports.anchorSymbol], __classPrivateFieldGet(this, _LazyEntity_lazyCursor, "f"));
+            (0, core_utils_1.assert)(result === 1 /* TreeNavigationResult.Ok */, 0x77a /* It is invalid to access an EditableTree node which no longer exists */);
+            this.context.withCursors.add(this);
+        }
+        return __classPrivateFieldGet(this, _LazyEntity_lazyCursor, "f");
+    }
+}
+exports.LazyEntity = LazyEntity;
+/**
+ * Prevent Entities from inheriting members from Object.prototype including:
+ * '__defineGetter__', '__defineSetter__', '__lookupGetter__', '__lookupSetter__', '__proto__',
+ * 'hasOwnProperty', 'isPrototypeOf', 'valueOf', 'propertyIsEnumerable', 'toLocaleString' and 'toString'.
+ *
+ * This opens up more options for field names on struct nodes.
+ */
+Object.setPrototypeOf(LazyEntity.prototype, null);
+//# sourceMappingURL=lazyEntity.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lazyEntity.js","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/lazyEntity.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\nimport { assert } from \"@fluidframework/core-utils\";\nimport {\n\tTreeNavigationResult,\n\tITreeSubscriptionCursor,\n\tITreeSubscriptionCursorState,\n} from \"../../core\";\nimport { fail, disposeSymbol, IDisposable } from \"../../util\";\nimport { Context } from \"./context\";\nimport {\n\tFlexTreeEntity,\n\tFlexTreeEntityKind,\n\tTreeStatus,\n\tboxedIterator,\n\tflexTreeMarker,\n} from \"./flexTreeTypes\";\n\n/**\n * Declare an enumerable own property on `T` under the key `key` using the implementation of one on `from`.\n */\nexport function makePropertyEnumerableOwn<T extends object>(\n\ttarget: T,\n\tkey: keyof T,\n\tfrom: object,\n): void {\n\tassert(\n\t\tObject.getOwnPropertyDescriptor(target, key) === undefined,\n\t\t0x776 /* preexisting property */,\n\t);\n\n\tconst descriptor = Object.getOwnPropertyDescriptor(from, key) ?? fail(\"missing property\");\n\tObject.defineProperty(target, key, { ...descriptor, enumerable: true });\n}\n\n/**\n * Modify a property on `T` under the key `key` to be not-enumerable\n */\nexport function makePropertyNotEnumerable<T extends object>(target: T, key: keyof T): void {\n\tmakePrivatePropertyNotEnumerable(target, key);\n}\n\n/**\n * Like {@link makePropertyNotEnumerable}, but less type safe so it works on private properties.\n */\nexport function makePrivatePropertyNotEnumerable(\n\ttarget: object,\n\tkey: string | symbol | number,\n): void {\n\tassert(\n\t\tObject.getOwnPropertyDescriptor(target, key)?.enumerable === true,\n\t\t0x777 /* missing property or not enumerable */,\n\t);\n\tObject.defineProperty(target, key, { enumerable: false });\n}\n\nexport const prepareForEditSymbol = Symbol(\"prepareForEdit\");\nexport const isFreedSymbol = Symbol(\"isFreed\");\nexport const tryMoveCursorToAnchorSymbol = Symbol(\"tryMoveCursorToAnchor\");\nexport const forgetAnchorSymbol = Symbol(\"forgetAnchor\");\nexport const cursorSymbol = Symbol(\"cursor\");\nexport const anchorSymbol = Symbol(\"anchor\");\n\n/**\n * This is a base class for lazy (cursor based) UntypedEntity implementations, which uniformly handles cursors and anchors.\n */\nexport abstract class LazyEntity<TSchema = unknown, TAnchor = unknown>\n\timplements FlexTreeEntity<TSchema>, IDisposable\n{\n\treadonly #lazyCursor: ITreeSubscriptionCursor;\n\tpublic readonly [anchorSymbol]: TAnchor;\n\n\tprotected constructor(\n\t\tpublic readonly context: Context,\n\t\tpublic readonly schema: TSchema,\n\t\tcursor: ITreeSubscriptionCursor,\n\t\tanchor: TAnchor,\n\t) {\n\t\tthis[anchorSymbol] = anchor;\n\t\tthis.#lazyCursor = cursor.fork();\n\t\tcontext.withCursors.add(this);\n\t\tthis.context.withAnchors.add(this);\n\n\t\t// Setup JS Object API:\n\t\tmakePropertyNotEnumerable(this, \"context\");\n\t\tmakePropertyNotEnumerable(this, \"schema\");\n\t\tmakePropertyNotEnumerable(this, anchorSymbol);\n\t}\n\n\tpublic abstract [boxedIterator](): IterableIterator<FlexTreeEntity>;\n\tpublic abstract get [flexTreeMarker](): FlexTreeEntityKind;\n\n\tpublic abstract treeStatus(): TreeStatus;\n\n\tpublic [disposeSymbol](): void {\n\t\tthis.#lazyCursor.free();\n\t\tthis.context.withCursors.delete(this);\n\t\tthis[forgetAnchorSymbol](this[anchorSymbol]);\n\t\tthis.context.withAnchors.delete(this);\n\t}\n\n\tpublic [prepareForEditSymbol](): void {\n\t\tthis.#lazyCursor.clear();\n\t\tthis.context.withCursors.delete(this);\n\t}\n\n\tpublic [isFreedSymbol](): boolean {\n\t\treturn this.#lazyCursor.state === ITreeSubscriptionCursorState.Freed;\n\t}\n\n\tpublic get [cursorSymbol](): ITreeSubscriptionCursor {\n\t\tif (this.#lazyCursor.state !== ITreeSubscriptionCursorState.Current) {\n\t\t\tassert(\n\t\t\t\tthis.#lazyCursor.state === ITreeSubscriptionCursorState.Cleared,\n\t\t\t\t0x778 /* Unset cursor should be in cleared state */,\n\t\t\t);\n\t\t\tassert(\n\t\t\t\tthis[anchorSymbol] !== undefined,\n\t\t\t\t0x779 /* EditableTree should have an anchor if it does not have a cursor */,\n\t\t\t);\n\t\t\tconst result = this[tryMoveCursorToAnchorSymbol](this[anchorSymbol], this.#lazyCursor);\n\t\t\tassert(\n\t\t\t\tresult === TreeNavigationResult.Ok,\n\t\t\t\t0x77a /* It is invalid to access an EditableTree node which no longer exists */,\n\t\t\t);\n\t\t\tthis.context.withCursors.add(this);\n\t\t}\n\t\treturn this.#lazyCursor;\n\t}\n\n\tprotected abstract [tryMoveCursorToAnchorSymbol](\n\t\tanchor: TAnchor,\n\t\tcursor: ITreeSubscriptionCursor,\n\t): TreeNavigationResult;\n\n\t/**\n\t * Called when disposing of this target, iff it has an anchor.\n\t */\n\tprotected abstract [forgetAnchorSymbol](anchor: TAnchor): void;\n}\n\n/**\n * Prevent Entities from inheriting members from Object.prototype including:\n * '__defineGetter__', '__defineSetter__', '__lookupGetter__', '__lookupSetter__', '__proto__',\n * 'hasOwnProperty', 'isPrototypeOf', 'valueOf', 'propertyIsEnumerable', 'toLocaleString' and 'toString'.\n *\n * This opens up more options for field names on struct nodes.\n */\nObject.setPrototypeOf(LazyEntity.prototype, null);\n"]}

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

@@ -0,0 +1,87 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { FieldKey, TreeNavigationResult, ITreeSubscriptionCursor, FieldAnchor, FieldUpPath } from "../../core";
+import { FieldKind } from "../modular-schema";
+import { FieldKinds } from "../default-schema";
+import { AllowedTypes, TreeFieldSchema } from "../typed-schema";
+import { LocalNodeKey, StableNodeKey } from "../node-key";
+import { Context } from "./context";
+import { FlexibleNodeContent, FlexTreeOptionalField, FlexTreeSequenceField, FlexTreeTypedField, FlexTreeTypedNodeUnion, FlexTreeUnboxNodeUnion, FlexTreeField, FlexTreeNode, FlexTreeRequiredField, boxedIterator, TreeStatus, FlexTreeNodeKeyField, FlexibleNodeSubSequence, FlexTreeEntityKind, flexTreeMarker } from "./flexTreeTypes";
+import { LazyEntity, forgetAnchorSymbol, tryMoveCursorToAnchorSymbol } from "./lazyEntity";
+export declare function makeField(context: Context, schema: TreeFieldSchema, cursor: ITreeSubscriptionCursor): FlexTreeField;
+/**
+ * A Proxy target, which together with a `fieldProxyHandler` implements a basic access to
+ * the nodes of {@link EditableField} by means of the cursors.
+ */
+export declare abstract class LazyField<TKind extends FieldKind, TTypes extends AllowedTypes> extends LazyEntity<TreeFieldSchema<TKind, TTypes>, FieldAnchor> implements FlexTreeField {
+    get [flexTreeMarker](): FlexTreeEntityKind.Field;
+    readonly key: FieldKey;
+    constructor(context: Context, schema: TreeFieldSchema<TKind, TTypes>, cursor: ITreeSubscriptionCursor, fieldAnchor: FieldAnchor);
+    is<TSchema extends TreeFieldSchema>(schema: TSchema): this is FlexTreeTypedField<TSchema>;
+    isSameAs(other: FlexTreeField): boolean;
+    get parent(): FlexTreeNode | undefined;
+    protected [tryMoveCursorToAnchorSymbol](anchor: FieldAnchor, cursor: ITreeSubscriptionCursor): TreeNavigationResult;
+    protected [forgetAnchorSymbol](anchor: FieldAnchor): void;
+    get length(): number;
+    atIndex(index: number): FlexTreeUnboxNodeUnion<TTypes>;
+    boxedAt(index: number): FlexTreeTypedNodeUnion<TTypes> | undefined;
+    map<U>(callbackfn: (value: FlexTreeUnboxNodeUnion<TTypes>, index: number) => U): U[];
+    mapBoxed<U>(callbackfn: (value: FlexTreeTypedNodeUnion<TTypes>, index: number) => U): U[];
+    [boxedIterator](): IterableIterator<FlexTreeTypedNodeUnion<TTypes>>;
+    [Symbol.iterator](): IterableIterator<FlexTreeUnboxNodeUnion<TTypes>>;
+    treeStatus(): TreeStatus;
+    getFieldPath(): FieldUpPath;
+    /**
+     * Returns the path to this field to use for editing. Throws iff this path is not {@link TreeStatus#InDocument}.
+     * This path is not valid to hold onto across edits: this must be recalled for each edit.
+     */
+    getFieldPathForEditing(): FieldUpPath;
+}
+export declare class LazySequence<TTypes extends AllowedTypes> extends LazyField<typeof FieldKinds.sequence, TTypes> implements FlexTreeSequenceField<TTypes> {
+    constructor(context: Context, schema: TreeFieldSchema<typeof FieldKinds.sequence, TTypes>, cursor: ITreeSubscriptionCursor, fieldAnchor: FieldAnchor);
+    at(index: number): FlexTreeUnboxNodeUnion<TTypes> | undefined;
+    get asArray(): readonly FlexTreeUnboxNodeUnion<TTypes>[];
+    private sequenceEditor;
+    insertAt(index: number, value: FlexibleNodeSubSequence<TTypes>): void;
+    insertAtStart(value: FlexibleNodeSubSequence<TTypes>): void;
+    insertAtEnd(value: FlexibleNodeSubSequence<TTypes>): void;
+    removeAt(index: number): void;
+    removeRange(start?: number, end?: number): void;
+    moveToStart(sourceIndex: number): void;
+    moveToStart(sourceIndex: number, source: FlexTreeSequenceField<AllowedTypes>): void;
+    moveToEnd(sourceIndex: number): void;
+    moveToEnd(sourceIndex: number, source: FlexTreeSequenceField<AllowedTypes>): void;
+    moveToIndex(index: number, sourceIndex: number): void;
+    moveToIndex(index: number, sourceIndex: number, source: FlexTreeSequenceField<AllowedTypes>): void;
+    moveRangeToStart(sourceStart: number, sourceEnd: number): void;
+    moveRangeToStart(sourceStart: number, sourceEnd: number, source: FlexTreeSequenceField<AllowedTypes>): void;
+    moveRangeToEnd(sourceStart: number, sourceEnd: number): void;
+    moveRangeToEnd(sourceStart: number, sourceEnd: number, source: FlexTreeSequenceField<AllowedTypes>): void;
+    moveRangeToIndex(index: number, sourceStart: number, sourceEnd: number): void;
+    moveRangeToIndex(index: number, sourceStart: number, sourceEnd: number, source: FlexTreeSequenceField<AllowedTypes>): void;
+    private _moveRangeToIndex;
+}
+export declare class LazyValueField<TTypes extends AllowedTypes> extends LazyField<typeof FieldKinds.required, TTypes> implements FlexTreeRequiredField<TTypes> {
+    constructor(context: Context, schema: TreeFieldSchema<typeof FieldKinds.required, TTypes>, cursor: ITreeSubscriptionCursor, fieldAnchor: FieldAnchor);
+    private valueFieldEditor;
+    get content(): FlexTreeUnboxNodeUnion<TTypes>;
+    set content(newContent: FlexibleNodeContent<TTypes>);
+    get boxedContent(): FlexTreeTypedNodeUnion<TTypes>;
+}
+export declare class LazyOptionalField<TTypes extends AllowedTypes> extends LazyField<typeof FieldKinds.optional, TTypes> implements FlexTreeOptionalField<TTypes> {
+    constructor(context: Context, schema: TreeFieldSchema<typeof FieldKinds.optional, TTypes>, cursor: ITreeSubscriptionCursor, fieldAnchor: FieldAnchor);
+    private optionalEditor;
+    get content(): FlexTreeUnboxNodeUnion<TTypes> | undefined;
+    set content(newContent: FlexibleNodeContent<TTypes> | undefined);
+    get boxedContent(): FlexTreeTypedNodeUnion<TTypes> | undefined;
+}
+export declare class LazyNodeKeyField<TTypes extends AllowedTypes> extends LazyField<typeof FieldKinds.nodeKey, TTypes> implements FlexTreeNodeKeyField {
+    constructor(context: Context, schema: TreeFieldSchema<typeof FieldKinds.nodeKey, TTypes>, cursor: ITreeSubscriptionCursor, fieldAnchor: FieldAnchor);
+    get localNodeKey(): LocalNodeKey;
+    get stableNodeKey(): StableNodeKey;
+}
+export declare class LazyForbiddenField<TTypes extends AllowedTypes> extends LazyField<typeof FieldKinds.forbidden, TTypes> {
+}
+//# sourceMappingURL=lazyField.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lazyField.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/lazyField.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EACN,QAAQ,EACR,oBAAoB,EACpB,uBAAuB,EAEvB,WAAW,EAEX,WAAW,EAMX,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAG9C,OAAO,EACN,UAAU,EAIV,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAyB,MAAM,aAAa,CAAC;AAEjF,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EACN,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,aAAa,EACb,YAAY,EACZ,qBAAqB,EACrB,aAAa,EACb,UAAU,EACV,oBAAoB,EACpB,uBAAuB,EACvB,kBAAkB,EAClB,cAAc,EACd,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACN,UAAU,EAGV,kBAAkB,EAIlB,2BAA2B,EAC3B,MAAM,cAAc,CAAC;AA4BtB,wBAAgB,SAAS,CACxB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,uBAAuB,GAC7B,aAAa,CAqBf;AAED;;;GAGG;AACH,8BAAsB,SAAS,CAAC,KAAK,SAAS,SAAS,EAAE,MAAM,SAAS,YAAY,CACnF,SAAQ,UAAU,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,WAAW,CAC9D,YAAW,aAAa;IAExB,IAAW,CAAC,cAAc,CAAC,IAAI,kBAAkB,CAAC,KAAK,CAEtD;IACD,SAAgB,GAAG,EAAE,QAAQ,CAAC;gBAG7B,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,EACtC,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW;IASlB,EAAE,CAAC,OAAO,SAAS,eAAe,EACxC,MAAM,EAAE,OAAO,GACb,IAAI,IAAI,kBAAkB,CAAC,OAAO,CAAC;IAS/B,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO;IAQ9C,IAAW,MAAM,IAAI,YAAY,GAAG,SAAS,CAU5C;cAEkB,CAAC,2BAA2B,CAAC,CAC/C,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,uBAAuB,GAC7B,oBAAoB;cAIJ,CAAC,kBAAkB,CAAC,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAKlE,IAAW,MAAM,IAAI,MAAM,CAE1B;IAEM,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB,CAAC,MAAM,CAAC;IAMtD,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB,CAAC,MAAM,CAAC,GAAG,SAAS;IAYlE,GAAG,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,KAAK,EAAE,sBAAsB,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,CAAC,EAAE;IAIpF,QAAQ,CAAC,CAAC,EAChB,UAAU,EAAE,CAAC,KAAK,EAAE,sBAAsB,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GACrE,CAAC,EAAE;IAIC,CAAC,aAAa,CAAC,IAAI,gBAAgB,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC;IAOnE,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC;IAMrE,UAAU,IAAI,UAAU;IAiBxB,YAAY,IAAI,WAAW;IAIlC;;;OAGG;IACI,sBAAsB,IAAI,WAAW;CAO5C;AAED,qBAAa,YAAY,CAAC,MAAM,SAAS,YAAY,CACpD,SAAQ,SAAS,CAAC,OAAO,UAAU,CAAC,QAAQ,EAAE,MAAM,CACpD,YAAW,qBAAqB,CAAC,MAAM,CAAC;gBAGvC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,eAAe,CAAC,OAAO,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,EAC3D,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW;IAOlB,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB,CAAC,MAAM,CAAC,GAAG,SAAS;IAWpE,IAAW,OAAO,IAAI,SAAS,sBAAsB,CAAC,MAAM,CAAC,EAAE,CAE9D;IAED,OAAO,CAAC,cAAc;IAMf,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,uBAAuB,CAAC,MAAM,CAAC,GAAG,IAAI;IAWrE,aAAa,CAAC,KAAK,EAAE,uBAAuB,CAAC,MAAM,CAAC,GAAG,IAAI;IAI3D,WAAW,CAAC,KAAK,EAAE,uBAAuB,CAAC,MAAM,CAAC,GAAG,IAAI;IAIzD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK7B,WAAW,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IAS/C,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IACtC,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,qBAAqB,CAAC,YAAY,CAAC,GAAG,IAAI;IAInF,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IACpC,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,qBAAqB,CAAC,YAAY,CAAC,GAAG,IAAI;IAIjF,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IACrD,WAAW,CACjB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,qBAAqB,CAAC,YAAY,CAAC,GACzC,IAAI;IASA,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAC9D,gBAAgB,CACtB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,qBAAqB,CAAC,YAAY,CAAC,GACzC,IAAI;IASA,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAC5D,cAAc,CACpB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,qBAAqB,CAAC,YAAY,CAAC,GACzC,IAAI;IASA,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAC7E,gBAAgB,CACtB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,qBAAqB,CAAC,YAAY,CAAC,GACzC,IAAI;IAUP,OAAO,CAAC,iBAAiB;CAmCzB;AAED,qBAAa,cAAc,CAAC,MAAM,SAAS,YAAY,CACtD,SAAQ,SAAS,CAAC,OAAO,UAAU,CAAC,QAAQ,EAAE,MAAM,CACpD,YAAW,qBAAqB,CAAC,MAAM,CAAC;gBAGvC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,eAAe,CAAC,OAAO,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,EAC3D,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW;IAOzB,OAAO,CAAC,gBAAgB;IAMxB,IAAW,OAAO,IAAI,sBAAsB,CAAC,MAAM,CAAC,CAEnD;IAED,IAAW,OAAO,CAAC,UAAU,EAAE,mBAAmB,CAAC,MAAM,CAAC,EAOzD;IAED,IAAW,YAAY,IAAI,sBAAsB,CAAC,MAAM,CAAC,CAExD;CACD;AAED,qBAAa,iBAAiB,CAAC,MAAM,SAAS,YAAY,CACzD,SAAQ,SAAS,CAAC,OAAO,UAAU,CAAC,QAAQ,EAAE,MAAM,CACpD,YAAW,qBAAqB,CAAC,MAAM,CAAC;gBAGvC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,eAAe,CAAC,OAAO,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,EAC3D,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW;IAOzB,OAAO,CAAC,cAAc;IAMtB,IAAW,OAAO,IAAI,sBAAsB,CAAC,MAAM,CAAC,GAAG,SAAS,CAE/D;IAED,IAAW,OAAO,CAAC,UAAU,EAAE,mBAAmB,CAAC,MAAM,CAAC,GAAG,SAAS,EAarE;IAED,IAAW,YAAY,IAAI,sBAAsB,CAAC,MAAM,CAAC,GAAG,SAAS,CAEpE;CACD;AAED,qBAAa,gBAAgB,CAAC,MAAM,SAAS,YAAY,CACxD,SAAQ,SAAS,CAAC,OAAO,UAAU,CAAC,OAAO,EAAE,MAAM,CACnD,YAAW,oBAAoB;gBAG9B,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,eAAe,CAAC,OAAO,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,EAC1D,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW;IAOzB,IAAW,YAAY,IAAI,YAAY,CAItC;IAED,IAAW,aAAa,IAAI,aAAa,CAQxC;CACD;AAED,qBAAa,kBAAkB,CAAC,MAAM,SAAS,YAAY,CAAE,SAAQ,SAAS,CAC7E,OAAO,UAAU,CAAC,SAAS,EAC3B,MAAM,CACN;CAAG"}