@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/lib/feature-libraries/chunked-forest/basicChunk.js

@@ -0,0 +1,455 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { assert } from "@fluidframework/core-utils";
+import { fail, ReferenceCountedBase } from "../../util";
+import { prefixPath, SynchronousCursor } from "../treeCursorUtils";
+import { cursorChunk, dummyRoot } from "./chunk";
+/**
+ * General purpose one node chunk.
+ */
+export class BasicChunk extends ReferenceCountedBase {
+    /**
+     * Create a tree chunk with ref count 1.
+     *
+     * @param fields - provides exclusive deep ownership of this map to this object (which might mutate it in the future).
+     * The caller must have already accounted for this reference to the children in this map (via `referenceAdded`),
+     * and any edits to this must update child reference counts.
+     * @param value - the value on this node, if any.
+     */
+    constructor(type, fields, value) {
+        super();
+        this.type = type;
+        this.fields = fields;
+        this.value = value;
+        this.topLevelLength = 1;
+    }
+    clone() {
+        const fields = new Map();
+        for (const [k, v] of this.fields) {
+            const field = v.map((child) => {
+                child.referenceAdded();
+                return child;
+            });
+            fields.set(k, field);
+        }
+        return new BasicChunk(this.type, fields, this.value);
+    }
+    cursor() {
+        return new BasicChunkCursor([this], [], [], [], [], [dummyRoot], 0, 0, 0, undefined);
+    }
+    dispose() {
+        for (const v of this.fields.values()) {
+            for (const child of v) {
+                child.referenceRemoved();
+            }
+        }
+    }
+}
+/**
+ * Cursor over basic chunks.
+ *
+ * @remarks This implementation is similar to StackCursor, however it is distinct because:
+ * 1. The children are chunks, which might have a top level length that greater than 1.
+ * 2. It needs to be able to delegate to cursors of other chunk formats it does not natively understand (See TODO below).
+ *
+ * TODO:
+ * This cursor currently only handles child chunks which are BasicChunks:
+ * BasicChunks should be an optimized fast path, and arbitrary chunk formats,
+ * like UniformChunk, should be supported by delegating to their cursor implementations.
+ */
+export class BasicChunkCursor extends SynchronousCursor {
+    /**
+     * Starts at root field which might be a detached sequence.
+     *
+     * @param root - sequence of BasicChunk which make up the contents of the root sequence.
+     * Since this cursor starts in `Fields` mode at the root, the siblings array when in fields mode is just the field keys,
+     * this is needed to get the actual root nodes when entering nodes of the root field.
+     * @param siblingStack - Stack of collections of siblings along the path through the tree:
+     * does not include current level (which is stored in `siblings`).
+     * Even levels in the stack (starting from 0) are keys and odd levels are sequences of nodes.
+     * @param indexStack - Stack of indices into the corresponding levels in `siblingStack`.
+     * @param indexOfChunkStack - Index of chunk in array of chunks. Only for Node levels.
+     * @param indexWithinChunkStack - Index within chunk selected by indexOfChunkStack. Only for Node levels.
+     * @param siblings - Siblings at the current level (not included in `siblingStack`).
+     * @param index - Index into `siblings`.
+     * @param indexOfChunk - Index of chunk in array of chunks. Only for Nodes mode.
+     * @param indexWithinChunk - Index within chunk selected by indexOfChunkStack. Only for Nodes mode.
+     * @param nestedCursor - When the outer cursor (this `BasicChunkCursor` cursor)
+     * navigates into a chunk it does not natively understand (currently anything other than `BasicChunk`s)
+     * it creates the `nestedCursor` over that chunk, and delegates all operations to it.
+     */
+    constructor(root, siblingStack, indexStack, indexOfChunkStack, 
+    // TODO: Currently only BasicChunks are supported, and the currently always have a top level length of 1.
+    // That makes this stack unneeded. When BasicChunkCursor is more feature complete, this stack should be reevaluated, and removed if possible.
+    indexWithinChunkStack, siblings, index, indexOfChunk, indexWithinChunk, nestedCursor) {
+        super();
+        this.root = root;
+        this.siblingStack = siblingStack;
+        this.indexStack = indexStack;
+        this.indexOfChunkStack = indexOfChunkStack;
+        this.indexWithinChunkStack = indexWithinChunkStack;
+        this.siblings = siblings;
+        this.index = index;
+        this.indexOfChunk = indexOfChunk;
+        this.indexWithinChunk = indexWithinChunk;
+        this.nestedCursor = nestedCursor;
+    }
+    get [cursorChunk]() {
+        if (this.nestedCursor !== undefined) {
+            return this.nestedCursor[cursorChunk];
+        }
+        assert(this.mode === 0 /* CursorLocationType.Nodes */, 0x57a /* must be in nodes mode */);
+        return this.siblings[this.indexOfChunk];
+    }
+    atChunkRoot() {
+        return (this.siblingStack.length < 2 &&
+            (this.nestedCursor === undefined || this.nestedCursor.atChunkRoot()));
+    }
+    fork() {
+        // Siblings arrays are not modified during navigation and do not need be be copied.
+        // This allows this copy to be shallow, and `this.siblings` below to not be copied as all.
+        return new BasicChunkCursor(this.root, [...this.siblingStack], [...this.indexStack], [...this.indexOfChunkStack], [...this.indexWithinChunkStack], this.siblings, this.index, this.indexOfChunk, this.indexWithinChunk, this.nestedCursor?.fork());
+    }
+    get mode() {
+        if (this.nestedCursor !== undefined) {
+            return this.nestedCursor.mode;
+        }
+        // Compute the number of nodes deep the current depth is.
+        // We want the floor of the result, which can computed using a bitwise shift assuming the depth is less than 2^31, which seems safe.
+        // eslint-disable-next-line no-bitwise
+        const halfHeight = (this.siblingStack.length + 1) >> 1;
+        assert(this.indexOfChunkStack.length === halfHeight, 0x51c /* unexpected indexOfChunkStack */);
+        assert(this.indexWithinChunkStack.length === halfHeight, 0x51d /* unexpected indexWithinChunkStack */);
+        return this.siblingStack.length % 2 === 0
+            ? 1 /* CursorLocationType.Fields */
+            : 0 /* CursorLocationType.Nodes */;
+    }
+    getFieldKey() {
+        if (this.nestedCursor !== undefined) {
+            return this.nestedCursor.getFieldKey();
+        }
+        assert(this.mode === 1 /* CursorLocationType.Fields */, 0x51e /* must be in fields mode */);
+        return this.siblings[this.index];
+    }
+    getStackedFieldKey(height) {
+        assert(height % 2 === 0, 0x51f /* must field height */);
+        return this.siblingStack[height][this.indexStack[height]];
+    }
+    getStackedNodeIndex(height) {
+        assert(height % 2 === 1, 0x520 /* must be node height */);
+        assert(height >= 0, 0x521 /* must not be above root */);
+        return this.indexStack[height];
+    }
+    getStackedNode(height) {
+        const index = this.getStackedNodeIndex(height);
+        return this.siblingStack[height][index];
+    }
+    getFieldLength() {
+        if (this.nestedCursor !== undefined) {
+            return this.nestedCursor.getFieldLength();
+        }
+        assert(this.mode === 1 /* CursorLocationType.Fields */, 0x522 /* must be in fields mode */);
+        let total = 0;
+        // TODO: optimize?
+        for (const chunk of this.getField()) {
+            total += chunk.topLevelLength;
+        }
+        return total;
+    }
+    enterNode(index) {
+        if (this.nestedCursor !== undefined) {
+            this.nestedCursor.enterNode(index);
+            return;
+        }
+        const found = this.firstNode() && this.seekNodes(index);
+        assert(found, 0x523 /* child must exist at index */);
+    }
+    getPath(prefix) {
+        if (this.nestedCursor !== undefined) {
+            return (this.nestedCursor.getPath(this.nestedPathPrefix(prefix)) ??
+                fail("nested cursors should not be root"));
+        }
+        assert(this.mode === 0 /* CursorLocationType.Nodes */, 0x524 /* must be in nodes mode */);
+        const path = this.getOffsetPath(0, prefix);
+        assert(path !== undefined, 0x55c /* field root cursor should never have undefined path */);
+        return path;
+    }
+    nestedPathPrefix(prefix) {
+        // This uses index offset for actual node, when it should use offset for start of chunk.
+        // To compensate, subtract this.indexWithinChunk below.
+        const rootPath = this.getOffsetPath(0, prefix) ?? fail("nested cursors should not be root");
+        return {
+            indexOffset: rootPath.parentIndex - this.indexWithinChunk,
+            rootFieldOverride: rootPath.parentField,
+            parent: rootPath.parent,
+        };
+    }
+    getFieldPath(prefix) {
+        if (this.nestedCursor !== undefined) {
+            return this.nestedCursor.getFieldPath(this.nestedPathPrefix(prefix));
+        }
+        assert(this.mode === 1 /* CursorLocationType.Fields */, 0x525 /* must be in fields mode */);
+        return {
+            field: this.indexStack.length === 1
+                ? prefix?.rootFieldOverride ?? this.getFieldKey()
+                : this.getFieldKey(),
+            parent: this.getOffsetPath(1, prefix),
+        };
+    }
+    getOffsetPath(offset, prefix) {
+        // It is more efficient to handle prefix directly in here rather than delegating to PrefixedPath.
+        const length = this.indexStack.length - offset;
+        if (length === -1) {
+            return prefix?.parent; // At root
+        }
+        assert(length > 0, 0x526 /* invalid offset to above root */);
+        assert(length % 2 === 1, 0x527 /* offset path must point to node not field */);
+        // Perf Note:
+        // This is O(depth) in tree.
+        // If many different anchors are created, this could be optimized to amortize the costs.
+        // For example, the cursor could cache UpPaths from the anchorSet when creating an anchor,
+        // then reuse them as a starting point when making another.
+        // Could cache this at one depth, and remember the depth.
+        // When navigating up, adjust cached anchor if present.
+        let path;
+        function updatePath(newPath) {
+            path = path === undefined ? prefixPath(prefix, newPath) : newPath;
+        }
+        // Skip top level, since root node in path is "undefined" and does not have a parent or index.
+        for (let height = 1; height < length; height += 2) {
+            const key = this.getStackedFieldKey(height - 1);
+            updatePath({
+                parent: path,
+                parentIndex: this.getStackedNodeIndex(height),
+                parentField: key,
+            });
+        }
+        updatePath({
+            parent: path,
+            parentIndex: offset === 0 ? this.index : this.getStackedNodeIndex(length),
+            parentField: this.getStackedFieldKey(length - 1),
+        });
+        return path;
+    }
+    enterField(key) {
+        if (this.nestedCursor !== undefined) {
+            this.nestedCursor.enterField(key);
+            return;
+        }
+        assert(this.mode === 0 /* CursorLocationType.Nodes */, 0x528 /* must be in nodes mode */);
+        this.siblingStack.push(this.siblings);
+        this.indexStack.push(this.index);
+        // For fields, siblings are only used for key lookup and
+        // nextField and which has arbitrary iteration order,
+        // so making a array of just key here works.
+        // This adds an allocation, so it's optimizing code simplicity and for the other use case (enumeration)
+        // at the cost of an allocation here.
+        this.index = 0;
+        this.siblings = [key];
+    }
+    nextField() {
+        if (this.nestedCursor !== undefined) {
+            return this.nestedCursor.nextField();
+        }
+        this.index += 1;
+        if (this.index === this.siblings.length) {
+            this.exitField();
+            return false;
+        }
+        return true;
+    }
+    firstField() {
+        if (this.nestedCursor !== undefined) {
+            return this.nestedCursor.firstField();
+        }
+        const fields = this.getNode().fields;
+        if (fields.size === 0) {
+            return false;
+        }
+        this.siblingStack.push(this.siblings);
+        this.indexStack.push(this.index);
+        this.index = 0;
+        this.siblings = [...fields.keys()]; // TODO: avoid this copy
+        return true;
+    }
+    seekNodes(offset) {
+        if (this.nestedCursor !== undefined) {
+            const atRoot = this.nestedCursor.atChunkRoot();
+            const stillIn = this.nestedCursor.seekNodes(offset);
+            if (!atRoot) {
+                return stillIn;
+            }
+            if (!stillIn) {
+                this.nestedCursor = undefined;
+            }
+        }
+        assert(this.mode === 0 /* CursorLocationType.Nodes */, 0x529 /* can only seekNodes when in Nodes */);
+        assert(this.indexOfChunk < this.siblings.length, 0x52a /* out of bounds indexOfChunk */);
+        this.indexWithinChunk += offset;
+        if (offset >= 0) {
+            const chunks = this.siblings;
+            while (this.indexWithinChunk >= chunks[this.indexOfChunk].topLevelLength) {
+                this.indexWithinChunk -= chunks[this.indexOfChunk].topLevelLength;
+                this.indexOfChunk++;
+                if (this.indexOfChunk === chunks.length) {
+                    this.exitNode();
+                    return false;
+                }
+                assert(this.indexOfChunk < this.siblings.length, 0x52b /* out of bounds indexOfChunk */);
+            }
+        }
+        else {
+            const chunks = this.siblings;
+            while (this.indexWithinChunk < 0) {
+                if (this.indexOfChunk === 0) {
+                    this.exitNode();
+                    return false;
+                }
+                this.indexOfChunk--;
+                this.indexWithinChunk += chunks[this.indexOfChunk].topLevelLength;
+            }
+        }
+        this.index += offset;
+        this.initNestedCursor();
+        return true;
+    }
+    firstNode() {
+        if (this.nestedCursor !== undefined) {
+            return this.nestedCursor.firstNode();
+        }
+        const siblings = this.getField();
+        if (siblings.length === 0) {
+            return false;
+        }
+        this.siblingStack.push(this.siblings);
+        this.indexStack.push(this.index);
+        this.indexOfChunkStack.push(this.indexOfChunk);
+        this.indexWithinChunkStack.push(this.indexWithinChunk);
+        this.index = 0;
+        this.siblings = siblings;
+        this.indexOfChunk = 0;
+        this.indexWithinChunk = 0;
+        this.initNestedCursor();
+        return true;
+    }
+    nextNode() {
+        if (this.nestedCursor !== undefined) {
+            const atRoot = this.nestedCursor.atChunkRoot();
+            const stillIn = this.nestedCursor.nextNode();
+            if (!atRoot) {
+                return stillIn;
+            }
+            if (!stillIn) {
+                this.nestedCursor = undefined;
+            }
+        }
+        assert(this.mode === 0 /* CursorLocationType.Nodes */, 0x52c /* can only nextNode when in Nodes */);
+        this.indexWithinChunk++;
+        if (this.indexWithinChunk ===
+            this.siblings[this.indexOfChunk].topLevelLength) {
+            this.indexOfChunk++;
+            if (this.indexOfChunk === this.siblings.length) {
+                this.exitNode();
+                return false;
+            }
+            this.indexWithinChunk = 0;
+            this.initNestedCursor();
+        }
+        this.index++;
+        return true;
+    }
+    initNestedCursor() {
+        assert(this.mode === 0 /* CursorLocationType.Nodes */, 0x55d /* can only initNestedCursor when in Nodes */);
+        const chunk = this.siblings[this.indexOfChunk];
+        this.nestedCursor = !(chunk instanceof BasicChunk) ? chunk.cursor() : undefined;
+        this.nestedCursor?.enterNode(this.indexWithinChunk);
+    }
+    exitField() {
+        if (this.nestedCursor !== undefined) {
+            return this.nestedCursor.exitField();
+        }
+        assert(this.mode === 1 /* CursorLocationType.Fields */, 0x52d /* can only navigate up from field when in field */);
+        this.siblings = this.siblingStack.pop() ?? fail("Unexpected siblingStack.length");
+        this.index = this.indexStack.pop() ?? fail("Unexpected indexStack.length");
+    }
+    exitNode() {
+        if (this.nestedCursor !== undefined) {
+            if (!this.nestedCursor.atChunkRoot()) {
+                return this.nestedCursor.exitNode();
+            }
+            this.nestedCursor = undefined;
+        }
+        assert(this.mode === 0 /* CursorLocationType.Nodes */, 0x52e /* can only navigate up from node when in node */);
+        this.siblings = this.siblingStack.pop() ?? fail("Unexpected siblingStack.length");
+        this.index = this.indexStack.pop() ?? fail("Unexpected indexStack.length");
+        this.indexOfChunk =
+            this.indexOfChunkStack.pop() ?? fail("Unexpected indexOfChunkStack.length");
+        this.indexWithinChunk =
+            this.indexWithinChunkStack.pop() ?? fail("Unexpected indexWithinChunkStack.length");
+    }
+    getNode() {
+        assert(this.mode === 0 /* CursorLocationType.Nodes */, 0x52f /* can only get node when in node */);
+        return this.siblings[this.index];
+    }
+    getField() {
+        if (this.siblingStack.length === 0) {
+            return this.root;
+        }
+        assert(this.mode === 1 /* CursorLocationType.Fields */, 0x530 /* can only get field when in fields */);
+        const parent = this.getStackedNode(this.indexStack.length - 1);
+        const key = this.getFieldKey();
+        const field = parent.fields.get(key) ?? [];
+        return field;
+    }
+    get value() {
+        if (this.nestedCursor !== undefined) {
+            return this.nestedCursor.value;
+        }
+        return this.getNode().value;
+    }
+    get type() {
+        if (this.nestedCursor !== undefined) {
+            return this.nestedCursor.type;
+        }
+        return this.getNode().type;
+    }
+    get fieldIndex() {
+        assert(this.mode === 0 /* CursorLocationType.Nodes */, 0x531 /* can only node's index when in node */);
+        if (this.nestedCursor !== undefined) {
+            if (this.nestedCursor.atChunkRoot()) {
+                // TODO: this.index
+                return this.nestedCursor.fieldIndex + this.nestedOffset();
+            }
+            return this.nestedCursor.fieldIndex;
+        }
+        return this.index;
+    }
+    /**
+     * Within the field that `nestedCursor` is nested in:
+     * returns the index within that field of the first node that is part of the chunk nestedCursor traverses.
+     */
+    nestedOffset() {
+        assert(this.nestedCursor !== undefined, 0x55e /* nested offset requires nested cursor */);
+        assert(!this.nestedCursor.atChunkRoot() ||
+            this.indexWithinChunk === this.nestedCursor.fieldIndex, 0x55f /* indexes should match if at root */);
+        return this.index - this.indexWithinChunk;
+    }
+    get chunkStart() {
+        if (this.nestedCursor !== undefined) {
+            if (this.nestedCursor.atChunkRoot()) {
+                return this.nestedCursor.chunkStart + this.nestedOffset();
+            }
+            return this.nestedCursor.chunkStart;
+        }
+        return this.fieldIndex;
+    }
+    get chunkLength() {
+        if (this.nestedCursor !== undefined) {
+            return this.nestedCursor.chunkLength;
+        }
+        return 1;
+    }
+}
+//# sourceMappingURL=basicChunk.js.map

package/lib/feature-libraries/chunked-forest/basicChunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"basicChunk.js","sourceRoot":"","sources":["../../../src/feature-libraries/chunked-forest/basicChunk.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\tFieldKey,\n\tTreeNodeSchemaIdentifier,\n\tCursorLocationType,\n\tFieldUpPath,\n\tUpPath,\n\tTreeValue,\n\tValue,\n\tTreeType,\n\tPathRootPrefix,\n} from \"../../core\";\nimport { fail, ReferenceCountedBase } from \"../../util\";\nimport { prefixPath, SynchronousCursor } from \"../treeCursorUtils\";\nimport { ChunkedCursor, cursorChunk, dummyRoot, TreeChunk } from \"./chunk\";\n\n/**\n * General purpose one node chunk.\n */\nexport class BasicChunk extends ReferenceCountedBase implements TreeChunk {\n\tpublic readonly topLevelLength: number = 1;\n\n\t/**\n\t * Create a tree chunk with ref count 1.\n\t *\n\t * @param fields - provides exclusive deep ownership of this map to this object (which might mutate it in the future).\n\t * The caller must have already accounted for this reference to the children in this map (via `referenceAdded`),\n\t * and any edits to this must update child reference counts.\n\t * @param value - the value on this node, if any.\n\t */\n\tpublic constructor(\n\t\tpublic type: TreeNodeSchemaIdentifier,\n\t\tpublic fields: Map<FieldKey, TreeChunk[]>,\n\t\tpublic value?: TreeValue,\n\t) {\n\t\tsuper();\n\t}\n\n\tpublic clone(): BasicChunk {\n\t\tconst fields = new Map<FieldKey, TreeChunk[]>();\n\t\tfor (const [k, v] of this.fields) {\n\t\t\tconst field = v.map((child) => {\n\t\t\t\tchild.referenceAdded();\n\t\t\t\treturn child;\n\t\t\t});\n\t\t\tfields.set(k, field);\n\t\t}\n\t\treturn new BasicChunk(this.type, fields, this.value);\n\t}\n\n\tpublic cursor(): ChunkedCursor {\n\t\treturn new BasicChunkCursor([this], [], [], [], [], [dummyRoot], 0, 0, 0, undefined);\n\t}\n\n\tprotected dispose(): void {\n\t\tfor (const v of this.fields.values()) {\n\t\t\tfor (const child of v) {\n\t\t\t\tchild.referenceRemoved();\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport type SiblingsOrKey = readonly TreeChunk[] | readonly FieldKey[];\n\n/**\n * Cursor over basic chunks.\n *\n * @remarks This implementation is similar to StackCursor, however it is distinct because:\n * 1. The children are chunks, which might have a top level length that greater than 1.\n * 2. It needs to be able to delegate to cursors of other chunk formats it does not natively understand (See TODO below).\n *\n * TODO:\n * This cursor currently only handles child chunks which are BasicChunks:\n * BasicChunks should be an optimized fast path, and arbitrary chunk formats,\n * like UniformChunk, should be supported by delegating to their cursor implementations.\n */\nexport class BasicChunkCursor extends SynchronousCursor implements ChunkedCursor {\n\t/**\n\t * Starts at root field which might be a detached sequence.\n\t *\n\t * @param root - sequence of BasicChunk which make up the contents of the root sequence.\n\t * Since this cursor starts in `Fields` mode at the root, the siblings array when in fields mode is just the field keys,\n\t * this is needed to get the actual root nodes when entering nodes of the root field.\n\t * @param siblingStack - Stack of collections of siblings along the path through the tree:\n\t * does not include current level (which is stored in `siblings`).\n\t * Even levels in the stack (starting from 0) are keys and odd levels are sequences of nodes.\n\t * @param indexStack - Stack of indices into the corresponding levels in `siblingStack`.\n\t * @param indexOfChunkStack - Index of chunk in array of chunks. Only for Node levels.\n\t * @param indexWithinChunkStack - Index within chunk selected by indexOfChunkStack. Only for Node levels.\n\t * @param siblings - Siblings at the current level (not included in `siblingStack`).\n\t * @param index - Index into `siblings`.\n\t * @param indexOfChunk - Index of chunk in array of chunks. Only for Nodes mode.\n\t * @param indexWithinChunk - Index within chunk selected by indexOfChunkStack. Only for Nodes mode.\n\t * @param nestedCursor - When the outer cursor (this `BasicChunkCursor` cursor)\n\t * navigates into a chunk it does not natively understand (currently anything other than `BasicChunk`s)\n\t * it creates the `nestedCursor` over that chunk, and delegates all operations to it.\n\t */\n\tpublic constructor(\n\t\tprotected root: readonly TreeChunk[],\n\t\tprotected readonly siblingStack: SiblingsOrKey[],\n\t\tprotected readonly indexStack: number[],\n\t\tprotected readonly indexOfChunkStack: number[],\n\t\t// TODO: Currently only BasicChunks are supported, and the currently always have a top level length of 1.\n\t\t// That makes this stack unneeded. When BasicChunkCursor is more feature complete, this stack should be reevaluated, and removed if possible.\n\t\tprotected readonly indexWithinChunkStack: number[],\n\t\tprotected siblings: SiblingsOrKey,\n\t\tprotected index: number,\n\t\tprotected indexOfChunk: number,\n\t\tprotected indexWithinChunk: number,\n\t\tprotected nestedCursor: ChunkedCursor | undefined,\n\t) {\n\t\tsuper();\n\t}\n\n\tpublic get [cursorChunk](): TreeChunk | undefined {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\treturn this.nestedCursor[cursorChunk];\n\t\t}\n\t\tassert(this.mode === CursorLocationType.Nodes, 0x57a /* must be in nodes mode */);\n\t\treturn (this.siblings as TreeChunk[])[this.indexOfChunk];\n\t}\n\n\tpublic atChunkRoot(): boolean {\n\t\treturn (\n\t\t\tthis.siblingStack.length < 2 &&\n\t\t\t(this.nestedCursor === undefined || this.nestedCursor.atChunkRoot())\n\t\t);\n\t}\n\n\tpublic fork(): BasicChunkCursor {\n\t\t// Siblings arrays are not modified during navigation and do not need be be copied.\n\t\t// This allows this copy to be shallow, and `this.siblings` below to not be copied as all.\n\t\treturn new BasicChunkCursor(\n\t\t\tthis.root,\n\t\t\t[...this.siblingStack],\n\t\t\t[...this.indexStack],\n\t\t\t[...this.indexOfChunkStack],\n\t\t\t[...this.indexWithinChunkStack],\n\t\t\tthis.siblings,\n\t\t\tthis.index,\n\t\t\tthis.indexOfChunk,\n\t\t\tthis.indexWithinChunk,\n\t\t\tthis.nestedCursor?.fork(),\n\t\t);\n\t}\n\n\tpublic get mode(): CursorLocationType {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\treturn this.nestedCursor.mode;\n\t\t}\n\t\t// Compute the number of nodes deep the current depth is.\n\t\t// We want the floor of the result, which can computed using a bitwise shift assuming the depth is less than 2^31, which seems safe.\n\t\t// eslint-disable-next-line no-bitwise\n\t\tconst halfHeight = (this.siblingStack.length + 1) >> 1;\n\t\tassert(\n\t\t\tthis.indexOfChunkStack.length === halfHeight,\n\t\t\t0x51c /* unexpected indexOfChunkStack */,\n\t\t);\n\t\tassert(\n\t\t\tthis.indexWithinChunkStack.length === halfHeight,\n\t\t\t0x51d /* unexpected indexWithinChunkStack */,\n\t\t);\n\t\treturn this.siblingStack.length % 2 === 0\n\t\t\t? CursorLocationType.Fields\n\t\t\t: CursorLocationType.Nodes;\n\t}\n\n\tpublic getFieldKey(): FieldKey {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\treturn this.nestedCursor.getFieldKey();\n\t\t}\n\t\tassert(this.mode === CursorLocationType.Fields, 0x51e /* must be in fields mode */);\n\t\treturn this.siblings[this.index] as FieldKey;\n\t}\n\n\tprivate getStackedFieldKey(height: number): FieldKey {\n\t\tassert(height % 2 === 0, 0x51f /* must field height */);\n\t\treturn this.siblingStack[height][this.indexStack[height]] as FieldKey;\n\t}\n\n\tprivate getStackedNodeIndex(height: number): number {\n\t\tassert(height % 2 === 1, 0x520 /* must be node height */);\n\t\tassert(height >= 0, 0x521 /* must not be above root */);\n\t\treturn this.indexStack[height];\n\t}\n\n\tprivate getStackedNode(height: number): BasicChunk {\n\t\tconst index = this.getStackedNodeIndex(height);\n\t\treturn (this.siblingStack[height] as readonly TreeChunk[])[index] as BasicChunk;\n\t}\n\n\tpublic getFieldLength(): number {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\treturn this.nestedCursor.getFieldLength();\n\t\t}\n\t\tassert(this.mode === CursorLocationType.Fields, 0x522 /* must be in fields mode */);\n\t\tlet total = 0;\n\t\t// TODO: optimize?\n\t\tfor (const chunk of this.getField()) {\n\t\t\ttotal += chunk.topLevelLength;\n\t\t}\n\t\treturn total;\n\t}\n\n\tpublic enterNode(index: number): void {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\tthis.nestedCursor.enterNode(index);\n\t\t\treturn;\n\t\t}\n\t\tconst found = this.firstNode() && this.seekNodes(index);\n\t\tassert(found, 0x523 /* child must exist at index */);\n\t}\n\n\tpublic getPath(prefix?: PathRootPrefix): UpPath {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\treturn (\n\t\t\t\tthis.nestedCursor.getPath(this.nestedPathPrefix(prefix)) ??\n\t\t\t\tfail(\"nested cursors should not be root\")\n\t\t\t);\n\t\t}\n\t\tassert(this.mode === CursorLocationType.Nodes, 0x524 /* must be in nodes mode */);\n\t\tconst path = this.getOffsetPath(0, prefix);\n\t\tassert(path !== undefined, 0x55c /* field root cursor should never have undefined path */);\n\t\treturn path;\n\t}\n\n\tprivate nestedPathPrefix(prefix?: PathRootPrefix): PathRootPrefix {\n\t\t// This uses index offset for actual node, when it should use offset for start of chunk.\n\t\t// To compensate, subtract this.indexWithinChunk below.\n\t\tconst rootPath: UpPath =\n\t\t\tthis.getOffsetPath(0, prefix) ?? fail(\"nested cursors should not be root\");\n\t\treturn {\n\t\t\tindexOffset: rootPath.parentIndex - this.indexWithinChunk,\n\t\t\trootFieldOverride: rootPath.parentField,\n\t\t\tparent: rootPath.parent,\n\t\t};\n\t}\n\n\tpublic getFieldPath(prefix?: PathRootPrefix): FieldUpPath {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\treturn this.nestedCursor.getFieldPath(this.nestedPathPrefix(prefix));\n\t\t}\n\t\tassert(this.mode === CursorLocationType.Fields, 0x525 /* must be in fields mode */);\n\t\treturn {\n\t\t\tfield:\n\t\t\t\tthis.indexStack.length === 1\n\t\t\t\t\t? prefix?.rootFieldOverride ?? this.getFieldKey()\n\t\t\t\t\t: this.getFieldKey(),\n\t\t\tparent: this.getOffsetPath(1, prefix),\n\t\t};\n\t}\n\n\tprivate getOffsetPath(offset: number, prefix: PathRootPrefix | undefined): UpPath | undefined {\n\t\t// It is more efficient to handle prefix directly in here rather than delegating to PrefixedPath.\n\n\t\tconst length = this.indexStack.length - offset;\n\t\tif (length === -1) {\n\t\t\treturn prefix?.parent; // At root\n\t\t}\n\n\t\tassert(length > 0, 0x526 /* invalid offset to above root */);\n\t\tassert(length % 2 === 1, 0x527 /* offset path must point to node not field */);\n\n\t\t// Perf Note:\n\t\t// This is O(depth) in tree.\n\t\t// If many different anchors are created, this could be optimized to amortize the costs.\n\t\t// For example, the cursor could cache UpPaths from the anchorSet when creating an anchor,\n\t\t// then reuse them as a starting point when making another.\n\t\t// Could cache this at one depth, and remember the depth.\n\t\t// When navigating up, adjust cached anchor if present.\n\n\t\tlet path: UpPath | undefined;\n\t\tfunction updatePath(newPath: UpPath): void {\n\t\t\tpath = path === undefined ? prefixPath(prefix, newPath) : newPath;\n\t\t}\n\n\t\t// Skip top level, since root node in path is \"undefined\" and does not have a parent or index.\n\t\tfor (let height = 1; height < length; height += 2) {\n\t\t\tconst key = this.getStackedFieldKey(height - 1);\n\t\t\tupdatePath({\n\t\t\t\tparent: path,\n\t\t\t\tparentIndex: this.getStackedNodeIndex(height),\n\t\t\t\tparentField: key,\n\t\t\t});\n\t\t}\n\n\t\tupdatePath({\n\t\t\tparent: path,\n\t\t\tparentIndex: offset === 0 ? this.index : this.getStackedNodeIndex(length),\n\t\t\tparentField: this.getStackedFieldKey(length - 1),\n\t\t});\n\t\treturn path;\n\t}\n\n\tpublic enterField(key: FieldKey): void {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\tthis.nestedCursor.enterField(key);\n\t\t\treturn;\n\t\t}\n\t\tassert(this.mode === CursorLocationType.Nodes, 0x528 /* must be in nodes mode */);\n\t\tthis.siblingStack.push(this.siblings);\n\t\tthis.indexStack.push(this.index);\n\n\t\t// For fields, siblings are only used for key lookup and\n\t\t// nextField and which has arbitrary iteration order,\n\t\t// so making a array of just key here works.\n\t\t// This adds an allocation, so it's optimizing code simplicity and for the other use case (enumeration)\n\t\t// at the cost of an allocation here.\n\t\tthis.index = 0;\n\t\tthis.siblings = [key];\n\t}\n\n\tpublic nextField(): boolean {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\treturn this.nestedCursor.nextField();\n\t\t}\n\t\tthis.index += 1;\n\t\tif (this.index === (this.siblings as []).length) {\n\t\t\tthis.exitField();\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t}\n\n\tpublic firstField(): boolean {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\treturn this.nestedCursor.firstField();\n\t\t}\n\t\tconst fields = this.getNode().fields;\n\t\tif (fields.size === 0) {\n\t\t\treturn false;\n\t\t}\n\n\t\tthis.siblingStack.push(this.siblings);\n\t\tthis.indexStack.push(this.index);\n\t\tthis.index = 0;\n\t\tthis.siblings = [...fields.keys()]; // TODO: avoid this copy\n\t\treturn true;\n\t}\n\n\tpublic seekNodes(offset: number): boolean {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\tconst atRoot = this.nestedCursor.atChunkRoot();\n\t\t\tconst stillIn = this.nestedCursor.seekNodes(offset);\n\t\t\tif (!atRoot) {\n\t\t\t\treturn stillIn;\n\t\t\t}\n\t\t\tif (!stillIn) {\n\t\t\t\tthis.nestedCursor = undefined;\n\t\t\t}\n\t\t}\n\t\tassert(\n\t\t\tthis.mode === CursorLocationType.Nodes,\n\t\t\t0x529 /* can only seekNodes when in Nodes */,\n\t\t);\n\t\tassert(this.indexOfChunk < this.siblings.length, 0x52a /* out of bounds indexOfChunk */);\n\n\t\tthis.indexWithinChunk += offset;\n\t\tif (offset >= 0) {\n\t\t\tconst chunks = this.siblings as TreeChunk[];\n\t\t\twhile (this.indexWithinChunk >= chunks[this.indexOfChunk].topLevelLength) {\n\t\t\t\tthis.indexWithinChunk -= chunks[this.indexOfChunk].topLevelLength;\n\t\t\t\tthis.indexOfChunk++;\n\t\t\t\tif (this.indexOfChunk === chunks.length) {\n\t\t\t\t\tthis.exitNode();\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tassert(\n\t\t\t\t\tthis.indexOfChunk < this.siblings.length,\n\t\t\t\t\t0x52b /* out of bounds indexOfChunk */,\n\t\t\t\t);\n\t\t\t}\n\t\t} else {\n\t\t\tconst chunks = this.siblings as TreeChunk[];\n\t\t\twhile (this.indexWithinChunk < 0) {\n\t\t\t\tif (this.indexOfChunk === 0) {\n\t\t\t\t\tthis.exitNode();\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tthis.indexOfChunk--;\n\t\t\t\tthis.indexWithinChunk += chunks[this.indexOfChunk].topLevelLength;\n\t\t\t}\n\t\t}\n\n\t\tthis.index += offset;\n\t\tthis.initNestedCursor();\n\t\treturn true;\n\t}\n\n\tpublic firstNode(): boolean {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\treturn this.nestedCursor.firstNode();\n\t\t}\n\t\tconst siblings = this.getField();\n\t\tif (siblings.length === 0) {\n\t\t\treturn false;\n\t\t}\n\t\tthis.siblingStack.push(this.siblings);\n\t\tthis.indexStack.push(this.index);\n\t\tthis.indexOfChunkStack.push(this.indexOfChunk);\n\t\tthis.indexWithinChunkStack.push(this.indexWithinChunk);\n\t\tthis.index = 0;\n\t\tthis.siblings = siblings;\n\t\tthis.indexOfChunk = 0;\n\t\tthis.indexWithinChunk = 0;\n\t\tthis.initNestedCursor();\n\t\treturn true;\n\t}\n\n\tpublic nextNode(): boolean {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\tconst atRoot = this.nestedCursor.atChunkRoot();\n\t\t\tconst stillIn = this.nestedCursor.nextNode();\n\t\t\tif (!atRoot) {\n\t\t\t\treturn stillIn;\n\t\t\t}\n\t\t\tif (!stillIn) {\n\t\t\t\tthis.nestedCursor = undefined;\n\t\t\t}\n\t\t}\n\t\tassert(this.mode === CursorLocationType.Nodes, 0x52c /* can only nextNode when in Nodes */);\n\t\tthis.indexWithinChunk++;\n\t\tif (\n\t\t\tthis.indexWithinChunk ===\n\t\t\t(this.siblings as TreeChunk[])[this.indexOfChunk].topLevelLength\n\t\t) {\n\t\t\tthis.indexOfChunk++;\n\t\t\tif (this.indexOfChunk === (this.siblings as TreeChunk[]).length) {\n\t\t\t\tthis.exitNode();\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tthis.indexWithinChunk = 0;\n\t\t\tthis.initNestedCursor();\n\t\t}\n\t\tthis.index++;\n\t\treturn true;\n\t}\n\n\tprivate initNestedCursor(): void {\n\t\tassert(\n\t\t\tthis.mode === CursorLocationType.Nodes,\n\t\t\t0x55d /* can only initNestedCursor when in Nodes */,\n\t\t);\n\t\tconst chunk = (this.siblings as TreeChunk[])[this.indexOfChunk];\n\t\tthis.nestedCursor = !(chunk instanceof BasicChunk) ? chunk.cursor() : undefined;\n\t\tthis.nestedCursor?.enterNode(this.indexWithinChunk);\n\t}\n\n\tpublic exitField(): void {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\treturn this.nestedCursor.exitField();\n\t\t}\n\t\tassert(\n\t\t\tthis.mode === CursorLocationType.Fields,\n\t\t\t0x52d /* can only navigate up from field when in field */,\n\t\t);\n\t\tthis.siblings = this.siblingStack.pop() ?? fail(\"Unexpected siblingStack.length\");\n\t\tthis.index = this.indexStack.pop() ?? fail(\"Unexpected indexStack.length\");\n\t}\n\n\tpublic exitNode(): void {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\tif (!this.nestedCursor.atChunkRoot()) {\n\t\t\t\treturn this.nestedCursor.exitNode();\n\t\t\t}\n\t\t\tthis.nestedCursor = undefined;\n\t\t}\n\t\tassert(\n\t\t\tthis.mode === CursorLocationType.Nodes,\n\t\t\t0x52e /* can only navigate up from node when in node */,\n\t\t);\n\t\tthis.siblings = this.siblingStack.pop() ?? fail(\"Unexpected siblingStack.length\");\n\t\tthis.index = this.indexStack.pop() ?? fail(\"Unexpected indexStack.length\");\n\t\tthis.indexOfChunk =\n\t\t\tthis.indexOfChunkStack.pop() ?? fail(\"Unexpected indexOfChunkStack.length\");\n\t\tthis.indexWithinChunk =\n\t\t\tthis.indexWithinChunkStack.pop() ?? fail(\"Unexpected indexWithinChunkStack.length\");\n\t}\n\n\tprivate getNode(): BasicChunk {\n\t\tassert(this.mode === CursorLocationType.Nodes, 0x52f /* can only get node when in node */);\n\t\treturn (this.siblings as TreeChunk[])[this.index] as BasicChunk;\n\t}\n\n\tprivate getField(): readonly TreeChunk[] {\n\t\tif (this.siblingStack.length === 0) {\n\t\t\treturn this.root;\n\t\t}\n\t\tassert(\n\t\t\tthis.mode === CursorLocationType.Fields,\n\t\t\t0x530 /* can only get field when in fields */,\n\t\t);\n\t\tconst parent = this.getStackedNode(this.indexStack.length - 1);\n\t\tconst key: FieldKey = this.getFieldKey();\n\t\tconst field = parent.fields.get(key) ?? [];\n\t\treturn field;\n\t}\n\n\tpublic get value(): Value {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\treturn this.nestedCursor.value;\n\t\t}\n\t\treturn this.getNode().value;\n\t}\n\n\tpublic get type(): TreeType {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\treturn this.nestedCursor.type;\n\t\t}\n\t\treturn this.getNode().type;\n\t}\n\n\tpublic get fieldIndex(): number {\n\t\tassert(\n\t\t\tthis.mode === CursorLocationType.Nodes,\n\t\t\t0x531 /* can only node's index when in node */,\n\t\t);\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\tif (this.nestedCursor.atChunkRoot()) {\n\t\t\t\t// TODO: this.index\n\t\t\t\treturn this.nestedCursor.fieldIndex + this.nestedOffset();\n\t\t\t}\n\t\t\treturn this.nestedCursor.fieldIndex;\n\t\t}\n\t\treturn this.index;\n\t}\n\n\t/**\n\t * Within the field that `nestedCursor` is nested in:\n\t * returns the index within that field of the first node that is part of the chunk nestedCursor traverses.\n\t */\n\tprivate nestedOffset(): number {\n\t\tassert(this.nestedCursor !== undefined, 0x55e /* nested offset requires nested cursor */);\n\t\tassert(\n\t\t\t!this.nestedCursor.atChunkRoot() ||\n\t\t\t\tthis.indexWithinChunk === this.nestedCursor.fieldIndex,\n\t\t\t0x55f /* indexes should match if at root */,\n\t\t);\n\t\treturn this.index - this.indexWithinChunk;\n\t}\n\n\tpublic get chunkStart(): number {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\tif (this.nestedCursor.atChunkRoot()) {\n\t\t\t\treturn this.nestedCursor.chunkStart + this.nestedOffset();\n\t\t\t}\n\t\t\treturn this.nestedCursor.chunkStart;\n\t\t}\n\t\treturn this.fieldIndex;\n\t}\n\n\tpublic get chunkLength(): number {\n\t\tif (this.nestedCursor !== undefined) {\n\t\t\treturn this.nestedCursor.chunkLength;\n\t\t}\n\t\treturn 1;\n\t}\n}\n"]}

package/lib/feature-libraries/chunked-forest/chunk.d.ts

@@ -0,0 +1,89 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { ITreeCursor, ITreeCursorSynchronous, FieldKey } from "../../core";
+import { ReferenceCounted } from "../../util";
+/**
+ * Contiguous part of the tree which get stored together in some data format.
+ * Copy-on-write, but optimized to be mutated in place when a chunk only has a single user (detected using reference counting).
+ * This allows for efficient cloning without major performance overheads for non-cloning scenarios.
+ */
+export interface TreeChunk extends ReferenceCounted {
+    /**
+     * The number of nodes at the top level of this chunk.
+     *
+     * If this chunk is included in a field, this is the amount this chunk contributes to the length of the field.
+     */
+    readonly topLevelLength: number;
+    /**
+     * Creates a cursor for navigating the content of this chunk.
+     *
+     * Starts in "fields" mode in a `dummyRoot` field containing the top level nodes.
+     *
+     * This cursor does not own a reference to the data:
+     * it is up to the caller of this function to ensure the cursor is not used after they release their owning ref to this chunk.
+     *
+     * TODO: consider starting this in "fields" mode above the top level
+     * which would compose better with utilities for processing sequences of nodes.
+     */
+    cursor(): ChunkedCursor;
+}
+/**
+ * The key used for the field that contains the root of chunks when not parented anywhere.
+ *
+ * For now this is using the document root key to ease testing/compatibility, but this may change.
+ */
+export declare const dummyRoot: FieldKey;
+/**
+ * A symbol for extracting a TreeChunk from {@link ITreeCursor}.
+ */
+export declare const cursorChunk: unique symbol;
+/**
+ * Cursors can optionally implement this interface, allowing querying them for the chunk they are traversing.
+ */
+interface WithChunk {
+    /**
+     * When in nodes mode, if a value is returned, it is a TreeChunk who's top level nodes are the
+     * chunkLength nodes starting from chunkStart.
+     *
+     *
+     * @remarks
+     * Note that there may be other tree representations with different chunk APIs and thus different ways to query them.
+     * The chunkStart and chunkLength values thus to not uniquely apply to the chunks accessed through this field.
+     *
+     * TODO:
+     * This API (including the chunk start and end on ITreeCUrsor) have some issues:
+     * 1. There are cases where multiple possible chunks could be considered.
+     * For example, when in a SequenceChunk, it could be returned, or the chunk within it could be.
+     * 2. When in a location other than the root of a chunk,
+     * it can't provide information about the containing chunk other than by allocating a new chunk that just represents that field.
+     *
+     * As more optimizations get implemented, this API may need to change to better address these issues.
+     */
+    readonly [cursorChunk]?: TreeChunk;
+}
+/**
+ * See {@link WithChunk}.
+ */
+export declare function tryGetChunk(cursor: ITreeCursor): undefined | TreeChunk;
+/**
+ * Cursor for a chunk which can be wrapped by another cursor.
+ *
+ * @remarks See `BasicChunkCursor` which uses this.
+ */
+export interface ChunkedCursor extends ITreeCursorSynchronous, WithChunk {
+    /**
+     * Checks if the cursor is in the top level nodes of the chunk.
+     *
+     * @returns true iff cursor is within the root field, including at a node within that field.
+     */
+    atChunkRoot(): boolean;
+    /**
+     * Clones the cursor to produce a new independent cursor.
+     * Does not add any counted references to any chunks.
+     */
+    fork(): ChunkedCursor;
+}
+export {};
+//# sourceMappingURL=chunk.d.ts.map

package/lib/feature-libraries/chunked-forest/chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/chunked-forest/chunk.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAEN,WAAW,EACX,sBAAsB,EACtB,QAAQ,EAER,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;GAIG;AACH,MAAM,WAAW,SAAU,SAAQ,gBAAgB;IAClD;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAEhC;;;;;;;;;;OAUG;IACH,MAAM,IAAI,aAAa,CAAC;CACxB;AAED;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,QAAuB,CAAC;AAEhD;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,OAAO,MAA8B,CAAC;AAEhE;;GAEG;AACH,UAAU,SAAS;IAClB;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC;CACnC;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,CAMtE;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAc,SAAQ,sBAAsB,EAAE,SAAS;IACvE;;;;OAIG;IACH,WAAW,IAAI,OAAO,CAAC;IAEvB;;;OAGG;IACH,IAAI,IAAI,aAAa,CAAC;CACtB"}

package/lib/feature-libraries/chunked-forest/chunk.js

@@ -0,0 +1,24 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { assert } from "@fluidframework/core-utils";
+import { rootFieldKey, } from "../../core";
+/**
+ * The key used for the field that contains the root of chunks when not parented anywhere.
+ *
+ * For now this is using the document root key to ease testing/compatibility, but this may change.
+ */
+export const dummyRoot = rootFieldKey;
+/**
+ * A symbol for extracting a TreeChunk from {@link ITreeCursor}.
+ */
+export const cursorChunk = Symbol("cursorChunk");
+/**
+ * See {@link WithChunk}.
+ */
+export function tryGetChunk(cursor) {
+    assert(cursor.mode === 0 /* CursorLocationType.Nodes */, 0x57b /* cursorChunk only accessible in nodes mode */);
+    return cursor[cursorChunk];
+}
+//# sourceMappingURL=chunk.js.map

package/lib/feature-libraries/chunked-forest/chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.js","sourceRoot":"","sources":["../../../src/feature-libraries/chunked-forest/chunk.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACpD,OAAO,EAKN,YAAY,GACZ,MAAM,YAAY,CAAC;AA8BpB;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAa,YAAY,CAAC;AAEhD;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAkB,MAAM,CAAC,aAAa,CAAC,CAAC;AA2BhE;;GAEG;AACH,MAAM,UAAU,WAAW,CAAC,MAAmB;IAC9C,MAAM,CACL,MAAM,CAAC,IAAI,qCAA6B,EACxC,KAAK,CAAC,+CAA+C,CACrD,CAAC;IACF,OAAQ,MAAoB,CAAC,WAAW,CAAC,CAAC;AAC3C,CAAC","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\tCursorLocationType,\n\tITreeCursor,\n\tITreeCursorSynchronous,\n\tFieldKey,\n\trootFieldKey,\n} from \"../../core\";\nimport { ReferenceCounted } from \"../../util\";\n\n/**\n * Contiguous part of the tree which get stored together in some data format.\n * Copy-on-write, but optimized to be mutated in place when a chunk only has a single user (detected using reference counting).\n * This allows for efficient cloning without major performance overheads for non-cloning scenarios.\n */\nexport interface TreeChunk extends ReferenceCounted {\n\t/**\n\t * The number of nodes at the top level of this chunk.\n\t *\n\t * If this chunk is included in a field, this is the amount this chunk contributes to the length of the field.\n\t */\n\treadonly topLevelLength: number;\n\n\t/**\n\t * Creates a cursor for navigating the content of this chunk.\n\t *\n\t * Starts in \"fields\" mode in a `dummyRoot` field containing the top level nodes.\n\t *\n\t * This cursor does not own a reference to the data:\n\t * it is up to the caller of this function to ensure the cursor is not used after they release their owning ref to this chunk.\n\t *\n\t * TODO: consider starting this in \"fields\" mode above the top level\n\t * which would compose better with utilities for processing sequences of nodes.\n\t */\n\tcursor(): ChunkedCursor;\n}\n\n/**\n * The key used for the field that contains the root of chunks when not parented anywhere.\n *\n * For now this is using the document root key to ease testing/compatibility, but this may change.\n */\nexport const dummyRoot: FieldKey = rootFieldKey;\n\n/**\n * A symbol for extracting a TreeChunk from {@link ITreeCursor}.\n */\nexport const cursorChunk: unique symbol = Symbol(\"cursorChunk\");\n\n/**\n * Cursors can optionally implement this interface, allowing querying them for the chunk they are traversing.\n */\ninterface WithChunk {\n\t/**\n\t * When in nodes mode, if a value is returned, it is a TreeChunk who's top level nodes are the\n\t * chunkLength nodes starting from chunkStart.\n\t *\n\t *\n\t * @remarks\n\t * Note that there may be other tree representations with different chunk APIs and thus different ways to query them.\n\t * The chunkStart and chunkLength values thus to not uniquely apply to the chunks accessed through this field.\n\t *\n\t * TODO:\n\t * This API (including the chunk start and end on ITreeCUrsor) have some issues:\n\t * 1. There are cases where multiple possible chunks could be considered.\n\t * For example, when in a SequenceChunk, it could be returned, or the chunk within it could be.\n\t * 2. When in a location other than the root of a chunk,\n\t * it can't provide information about the containing chunk other than by allocating a new chunk that just represents that field.\n\t *\n\t * As more optimizations get implemented, this API may need to change to better address these issues.\n\t */\n\treadonly [cursorChunk]?: TreeChunk;\n}\n\n/**\n * See {@link WithChunk}.\n */\nexport function tryGetChunk(cursor: ITreeCursor): undefined | TreeChunk {\n\tassert(\n\t\tcursor.mode === CursorLocationType.Nodes,\n\t\t0x57b /* cursorChunk only accessible in nodes mode */,\n\t);\n\treturn (cursor as WithChunk)[cursorChunk];\n}\n\n/**\n * Cursor for a chunk which can be wrapped by another cursor.\n *\n * @remarks See `BasicChunkCursor` which uses this.\n */\nexport interface ChunkedCursor extends ITreeCursorSynchronous, WithChunk {\n\t/**\n\t * Checks if the cursor is in the top level nodes of the chunk.\n\t *\n\t * @returns true iff cursor is within the root field, including at a node within that field.\n\t */\n\tatChunkRoot(): boolean;\n\n\t/**\n\t * Clones the cursor to produce a new independent cursor.\n\t * Does not add any counted references to any chunks.\n\t */\n\tfork(): ChunkedCursor;\n}\n"]}