@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/dist/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,2DAAoD;AACpD,qCAMoB;AA8BpB;;;;GAIG;AACU,QAAA,SAAS,GAAa,mBAAY,CAAC;AAEhD;;GAEG;AACU,QAAA,WAAW,GAAkB,MAAM,CAAC,aAAa,CAAC,CAAC;AA2BhE;;GAEG;AACH,SAAgB,WAAW,CAAC,MAAmB;IAC9C,IAAA,mBAAM,EACL,MAAM,CAAC,IAAI,qCAA6B,EACxC,KAAK,CAAC,+CAA+C,CACrD,CAAC;IACF,OAAQ,MAAoB,CAAC,mBAAW,CAAC,CAAC;AAC3C,CAAC;AAND,kCAMC","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"]}

package/dist/feature-libraries/chunked-forest/chunkTree.d.ts

@@ -0,0 +1,156 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { FieldKey, TreeFieldStoredSchema, ITreeCursorSynchronous, TreeNodeSchemaIdentifier, Value, TreeStoredSchemaSubscription, TreeStoredSchema, StoredSchemaCollection } from "../../core";
+import { FullSchemaPolicy } from "../modular-schema";
+import { TreeChunk } from "./chunk";
+import { BasicChunk } from "./basicChunk";
+import { FieldShape, TreeShape, UniformChunk } from "./uniformChunk";
+export interface Disposable {
+    /**
+     * Cleans up resources used by this, such as inbound event registrations.
+     */
+    dispose(): void;
+}
+/**
+ * Creates a ChunkPolicy which responds to schema changes.
+ */
+export declare function makeTreeChunker(schema: TreeStoredSchemaSubscription, policy: FullSchemaPolicy): IChunker;
+/**
+ * Extends ChunkPolicy to include stateful details required by ChunkedForest.
+ *
+ * This extra complexity is mostly due to the fact that schema can change over time,
+ * and that chunk policy uses caching which thus needs invalidation.
+ */
+export interface IChunker extends ChunkPolicy, Disposable {
+    readonly schema: TreeStoredSchemaSubscription;
+    clone(schema: TreeStoredSchemaSubscription): IChunker;
+}
+/**
+ * Indicates that there are multiple possible `TreeShape` trees with a given type can have.
+ *
+ * @remarks
+ * For example, a schema transitively containing a sequence field, optional field, or allowing multiple child types will be Polymorphic.
+ * See `tryShapeFromSchema` for how to tell if a type is Polymorphic.
+ *
+ * TODO: cache some of the possible shapes here.
+ */
+export declare class Polymorphic {
+}
+/**
+ * See `Polymorphic`.
+ * For now Polymorphic is stateless, so just use a singleton.
+ */
+export declare const polymorphic: Polymorphic;
+/**
+ * Information about the possible shapes a tree could take based on its type.
+ * Note that this information is for a specific version of the schema.
+ */
+export type ShapeInfo = TreeShape | Polymorphic;
+export declare class Chunker implements IChunker {
+    readonly schema: TreeStoredSchemaSubscription;
+    readonly policy: FullSchemaPolicy;
+    readonly sequenceChunkSplitThreshold: number;
+    readonly sequenceChunkInlineThreshold: number;
+    readonly uniformChunkNodeCount: number;
+    private readonly tryShapeFromSchema;
+    /**
+     * Cache for information about possible shapes for types.
+     * Corresponds to the version of the schema in `schema`.
+     * Cleared when `schema` changes.
+     */
+    private readonly typeShapes;
+    private unregisterSchemaCallback;
+    constructor(schema: TreeStoredSchemaSubscription, policy: FullSchemaPolicy, sequenceChunkSplitThreshold: number, sequenceChunkInlineThreshold: number, uniformChunkNodeCount: number, tryShapeFromSchema: (schema: TreeStoredSchema, policy: FullSchemaPolicy, type: TreeNodeSchemaIdentifier, shapes: Map<TreeNodeSchemaIdentifier, ShapeInfo>) => ShapeInfo);
+    clone(schema: TreeStoredSchemaSubscription): IChunker;
+    shapeFromSchema(schema: TreeNodeSchemaIdentifier): ShapeInfo;
+    dispose(): void;
+    private schemaChanged;
+}
+/**
+ * Get a TreeChunk for the current node (and its children) of cursor.
+ * This will copy if needed, but add refs to existing chunks which hold the data.
+ *
+ * @param cursor - cursor in nodes mode
+ */
+export declare function chunkTree(cursor: ITreeCursorSynchronous, policy: ChunkPolicy): TreeChunk;
+/**
+ * Get a TreeChunk[] for the current field (and its children) of cursor.
+ * This will copy if needed, but add refs to existing chunks which hold the data.
+ */
+export declare function chunkField(cursor: ITreeCursorSynchronous, policy: ChunkPolicy): TreeChunk[];
+/**
+ * Get a TreeChunk for the current field (and its children) of cursor.
+ * Like {@link chunkField}, but forces the results into a single TreeChunk.
+ */
+export declare function chunkFieldSingle(cursor: ITreeCursorSynchronous, policy: ChunkPolicy): TreeChunk;
+/**
+ * Get a BasicChunk for the current node (and its children) of cursor.
+ * This will copy if needed, and add refs to existing chunks which hold the data.
+ */
+export declare function basicChunkTree(cursor: ITreeCursorSynchronous, policy: ChunkPolicy): BasicChunk;
+export declare function makePolicy(policy?: Partial<ChunkPolicy>): ChunkPolicy;
+export declare function shapesFromSchema(schema: StoredSchemaCollection, policy: FullSchemaPolicy): Map<TreeNodeSchemaIdentifier, ShapeInfo>;
+/**
+ * If `schema` has only one shape, return it.
+ *
+ * Note that this does not tolerate optional or sequence fields, nor does it optimize for patterns of specific values.
+ */
+export declare function tryShapeFromSchema(schema: StoredSchemaCollection, policy: FullSchemaPolicy, type: TreeNodeSchemaIdentifier, shapes: Map<TreeNodeSchemaIdentifier, ShapeInfo>): ShapeInfo;
+/**
+ * If `schema` has only one shape, return it.
+ *
+ * Note that this does not tolerate optional or sequence fields, nor does it optimize for patterns of specific values.
+ */
+export declare function tryShapeFromFieldSchema(schema: StoredSchemaCollection, policy: FullSchemaPolicy, type: TreeFieldStoredSchema, key: FieldKey, shapes: Map<TreeNodeSchemaIdentifier, ShapeInfo>): FieldShape | undefined;
+/**
+ * Default settings for use for {@link ChunkPolicy}.
+ * Use `makeTreeChunker` to create a policy with the defaults, but leverages to schema.
+ */
+export declare const defaultChunkPolicy: ChunkPolicy;
+export declare const basicOnlyChunkPolicy: ChunkPolicy;
+/**
+ * Policy for how to chunk a tree.
+ */
+export interface ChunkPolicy {
+    /**
+     * Group sequences longer than this into into sequence chunks of this length or less.
+     *
+     * Must be at least 2.
+     * Can be set to `Number.POSITIVE_INFINITY` to never introduce extra sequence chunks.
+     */
+    readonly sequenceChunkSplitThreshold: number;
+    /**
+     * SequenceChunks this long or shorter may get inlined into their parent chunk.
+     */
+    readonly sequenceChunkInlineThreshold: number;
+    /**
+     * Maximum total nodes to put in a UniformChunk.
+     */
+    readonly uniformChunkNodeCount: number;
+    /**
+     * Returns information about the shapes trees of type `schema` can take.
+     */
+    shapeFromSchema(schema: TreeNodeSchemaIdentifier): ShapeInfo;
+}
+/**
+ * @param cursor - cursor in nodes mode
+ * @param policy - heuristics to impact chunking
+ * @param length - how many nodes to process (at the top level)
+ * @param skipLastNavigation - if true, leaves the cursor at the last node instead of moving off of it.
+ */
+export declare function chunkRange(cursor: ITreeCursorSynchronous, policy: ChunkPolicy, length: number, skipLastNavigation: boolean): TreeChunk[];
+export declare function insertValues(cursor: ITreeCursorSynchronous, shape: TreeShape, values: Value[]): void;
+/**
+ * Read up to `maxTopLevelLength` nodes from `cursor`, stopping when limit is hit or type of node changes.
+ *
+ * This requires that the all trees with matching type match the provided shape.
+ * This cannot be used if other shapes are possible for this type.
+ *
+ * If this stops early due to the type changing, `skipLastNavigation` is not involved:
+ * `skipLastNavigation` only determines if the cursor will be left on the node after the last one (possibly exiting the field)
+ * if the full length is used.
+ */
+export declare function uniformChunkFromCursor(cursor: ITreeCursorSynchronous, shape: TreeShape, maxTopLevelLength: number, skipLastNavigation: boolean): UniformChunk;
+//# sourceMappingURL=chunkTree.d.ts.map

package/dist/feature-libraries/chunked-forest/chunkTree.d.ts.map

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

package/dist/feature-libraries/chunked-forest/chunkTree.js

@@ -0,0 +1,357 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniformChunkFromCursor = exports.insertValues = exports.chunkRange = exports.basicOnlyChunkPolicy = exports.defaultChunkPolicy = exports.tryShapeFromFieldSchema = exports.tryShapeFromSchema = exports.shapesFromSchema = exports.makePolicy = exports.basicChunkTree = exports.chunkFieldSingle = exports.chunkField = exports.chunkTree = exports.Chunker = exports.polymorphic = exports.Polymorphic = exports.makeTreeChunker = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const core_1 = require("../../core");
+const util_1 = require("../../util");
+const multiplicity_1 = require("../multiplicity");
+const chunk_1 = require("./chunk");
+const basicChunk_1 = require("./basicChunk");
+const uniformChunk_1 = require("./uniformChunk");
+const sequenceChunk_1 = require("./sequenceChunk");
+/**
+ * Creates a ChunkPolicy which responds to schema changes.
+ */
+function makeTreeChunker(schema, policy) {
+    return new Chunker(schema, policy, exports.defaultChunkPolicy.sequenceChunkInlineThreshold, exports.defaultChunkPolicy.sequenceChunkInlineThreshold, exports.defaultChunkPolicy.uniformChunkNodeCount, tryShapeFromSchema);
+}
+exports.makeTreeChunker = makeTreeChunker;
+/**
+ * Indicates that there are multiple possible `TreeShape` trees with a given type can have.
+ *
+ * @remarks
+ * For example, a schema transitively containing a sequence field, optional field, or allowing multiple child types will be Polymorphic.
+ * See `tryShapeFromSchema` for how to tell if a type is Polymorphic.
+ *
+ * TODO: cache some of the possible shapes here.
+ */
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+class Polymorphic {
+}
+exports.Polymorphic = Polymorphic;
+/**
+ * See `Polymorphic`.
+ * For now Polymorphic is stateless, so just use a singleton.
+ */
+exports.polymorphic = new Polymorphic();
+class Chunker {
+    constructor(schema, policy, sequenceChunkSplitThreshold, sequenceChunkInlineThreshold, uniformChunkNodeCount, 
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    tryShapeFromSchema) {
+        this.schema = schema;
+        this.policy = policy;
+        this.sequenceChunkSplitThreshold = sequenceChunkSplitThreshold;
+        this.sequenceChunkInlineThreshold = sequenceChunkInlineThreshold;
+        this.uniformChunkNodeCount = uniformChunkNodeCount;
+        this.tryShapeFromSchema = tryShapeFromSchema;
+        /**
+         * Cache for information about possible shapes for types.
+         * Corresponds to the version of the schema in `schema`.
+         * Cleared when `schema` changes.
+         */
+        this.typeShapes = new Map();
+    }
+    clone(schema) {
+        // This does not preserve the cache.
+        // This is probably fine, but is a potential way it could be optimized in the future (with care to ensure invalidation work properly).
+        return new Chunker(schema, this.policy, this.sequenceChunkSplitThreshold, this.sequenceChunkInlineThreshold, this.uniformChunkNodeCount, this.tryShapeFromSchema);
+    }
+    shapeFromSchema(schema) {
+        const cached = this.typeShapes.get(schema);
+        if (cached !== undefined) {
+            return cached;
+        }
+        this.unregisterSchemaCallback = this.schema.on("afterSchemaChange", () => this.schemaChanged());
+        return this.tryShapeFromSchema(this.schema, this.policy, schema, this.typeShapes);
+    }
+    dispose() {
+        // Remove subscription for changes via dependent.
+        this.schemaChanged();
+    }
+    schemaChanged() {
+        this.typeShapes.clear();
+        if (this.unregisterSchemaCallback) {
+            this.unregisterSchemaCallback();
+            this.unregisterSchemaCallback = undefined;
+        }
+    }
+}
+exports.Chunker = Chunker;
+/**
+ * Get a TreeChunk for the current node (and its children) of cursor.
+ * This will copy if needed, but add refs to existing chunks which hold the data.
+ *
+ * @param cursor - cursor in nodes mode
+ */
+function chunkTree(cursor, policy) {
+    return chunkRange(cursor, policy, 1, true)[0];
+}
+exports.chunkTree = chunkTree;
+/**
+ * Get a TreeChunk[] for the current field (and its children) of cursor.
+ * This will copy if needed, but add refs to existing chunks which hold the data.
+ */
+function chunkField(cursor, policy) {
+    const length = cursor.getFieldLength();
+    const started = cursor.firstNode();
+    (0, core_utils_1.assert)(started, 0x57c /* field to chunk should have at least one node */);
+    return chunkRange(cursor, policy, length, false);
+}
+exports.chunkField = chunkField;
+/**
+ * Get a TreeChunk for the current field (and its children) of cursor.
+ * Like {@link chunkField}, but forces the results into a single TreeChunk.
+ */
+function chunkFieldSingle(cursor, policy) {
+    const chunks = chunkField(cursor, policy);
+    if (chunks.length === 1) {
+        return chunks[0];
+    }
+    return new sequenceChunk_1.SequenceChunk(chunks);
+}
+exports.chunkFieldSingle = chunkFieldSingle;
+/**
+ * Get a BasicChunk for the current node (and its children) of cursor.
+ * This will copy if needed, and add refs to existing chunks which hold the data.
+ */
+function basicChunkTree(cursor, policy) {
+    // symbol based fast path to check for BasicChunk:
+    // return existing chunk with a increased ref count if possible.
+    const chunk = (0, chunk_1.tryGetChunk)(cursor);
+    if (chunk instanceof basicChunk_1.BasicChunk) {
+        chunk.referenceAdded();
+        return chunk;
+    }
+    return newBasicChunkTree(cursor, policy);
+}
+exports.basicChunkTree = basicChunkTree;
+function makePolicy(policy) {
+    const withDefaults = { ...exports.defaultChunkPolicy, ...policy };
+    // TODO: move this to a top level policy validation
+    (0, core_utils_1.assert)(withDefaults.sequenceChunkSplitThreshold >= 2, 0x57d /* sequenceChunkThreshold must be at least 2 */);
+    return withDefaults;
+}
+exports.makePolicy = makePolicy;
+function shapesFromSchema(schema, policy) {
+    const shapes = new Map();
+    for (const identifier of schema.nodeSchema.keys()) {
+        tryShapeFromSchema(schema, policy, identifier, shapes);
+    }
+    return shapes;
+}
+exports.shapesFromSchema = shapesFromSchema;
+/**
+ * If `schema` has only one shape, return it.
+ *
+ * Note that this does not tolerate optional or sequence fields, nor does it optimize for patterns of specific values.
+ */
+function tryShapeFromSchema(schema, policy, type, shapes) {
+    return (0, util_1.getOrCreate)(shapes, type, () => {
+        const treeSchema = schema.nodeSchema.get(type) ?? (0, util_1.fail)("missing schema");
+        if (treeSchema instanceof core_1.LeafNodeStoredSchema) {
+            return new uniformChunk_1.TreeShape(type, true, []);
+        }
+        if (treeSchema instanceof core_1.ObjectNodeStoredSchema) {
+            const fieldsArray = [];
+            for (const [key, field] of treeSchema.objectNodeFields) {
+                const fieldShape = tryShapeFromFieldSchema(schema, policy, field, key, shapes);
+                if (fieldShape === undefined) {
+                    return exports.polymorphic;
+                }
+                fieldsArray.push(fieldShape);
+            }
+            return new uniformChunk_1.TreeShape(type, false, fieldsArray);
+        }
+        return exports.polymorphic;
+    });
+}
+exports.tryShapeFromSchema = tryShapeFromSchema;
+/**
+ * If `schema` has only one shape, return it.
+ *
+ * Note that this does not tolerate optional or sequence fields, nor does it optimize for patterns of specific values.
+ */
+function tryShapeFromFieldSchema(schema, policy, type, key, shapes) {
+    const kind = policy.fieldKinds.get(type.kind.identifier) ?? (0, util_1.fail)("missing FieldKind");
+    if (kind.multiplicity !== multiplicity_1.Multiplicity.Single) {
+        return undefined;
+    }
+    if (type.types?.size !== 1) {
+        return undefined;
+    }
+    const childType = [...type.types][0];
+    const childShape = tryShapeFromSchema(schema, policy, childType, shapes);
+    if (childShape instanceof Polymorphic) {
+        return undefined;
+    }
+    return [key, childShape, 1];
+}
+exports.tryShapeFromFieldSchema = tryShapeFromFieldSchema;
+/**
+ * Default settings for use for {@link ChunkPolicy}.
+ * Use `makeTreeChunker` to create a policy with the defaults, but leverages to schema.
+ */
+exports.defaultChunkPolicy = {
+    // Currently ChunkedForest and BasicTreeCursor don't handle SequenceChunks very efficiently:
+    // they likely add more overhead than they save for now, so don't create them.
+    sequenceChunkSplitThreshold: Number.POSITIVE_INFINITY,
+    sequenceChunkInlineThreshold: Number.POSITIVE_INFINITY,
+    // Current UniformChunk handling doesn't scale well to large chunks, so set a modest size limit:
+    uniformChunkNodeCount: 400,
+    // Without knowing what the schema is, all shapes are possible.
+    // Use `makeTreeChunker` to do better.
+    shapeFromSchema: () => exports.polymorphic,
+};
+exports.basicOnlyChunkPolicy = {
+    sequenceChunkSplitThreshold: Number.POSITIVE_INFINITY,
+    sequenceChunkInlineThreshold: Number.POSITIVE_INFINITY,
+    uniformChunkNodeCount: 0,
+    shapeFromSchema: () => exports.polymorphic,
+};
+function newBasicChunkTree(cursor, policy) {
+    return new basicChunk_1.BasicChunk(cursor.type, new Map((0, core_1.mapCursorFields)(cursor, () => [cursor.getFieldKey(), chunkField(cursor, policy)])), cursor.value);
+}
+/**
+ * @param cursor - cursor in nodes mode
+ * @param policy - heuristics to impact chunking
+ * @param length - how many nodes to process (at the top level)
+ * @param skipLastNavigation - if true, leaves the cursor at the last node instead of moving off of it.
+ */
+function chunkRange(cursor, policy, length, skipLastNavigation) {
+    (0, core_utils_1.assert)(cursor.mode === 0 /* CursorLocationType.Nodes */, 0x57e /* should be in nodes */);
+    let output = [];
+    let remaining = length;
+    while (remaining > 0) {
+        (0, core_utils_1.assert)(cursor.mode === 0 /* CursorLocationType.Nodes */, 0x57f /* should be in nodes */);
+        const start = cursor.chunkStart;
+        let reusedChunk = false;
+        // symbol based fast path to check for chunk:
+        // return existing chunk with a increased ref count if possible.
+        if (start === cursor.fieldIndex) {
+            const chunkLength = cursor.chunkLength;
+            if (chunkLength <= remaining) {
+                const chunk = (0, chunk_1.tryGetChunk)(cursor);
+                if (chunk !== undefined) {
+                    if (chunk instanceof sequenceChunk_1.SequenceChunk &&
+                        chunk.subChunks.length <= policy.sequenceChunkInlineThreshold) {
+                        // If sequence chunk, and its very short, inline it.
+                        // Note that this is not recursive: there may be short sequences nested below this which are not inlined.
+                        for (const subChunk of chunk.subChunks) {
+                            subChunk.referenceAdded();
+                            output.push(subChunk);
+                        }
+                    }
+                    chunk.referenceAdded();
+                    output.push(chunk);
+                    remaining -= chunkLength;
+                    reusedChunk = true;
+                    let seek = chunkLength;
+                    if (skipLastNavigation && remaining === 0) {
+                        seek -= 1;
+                    }
+                    cursor.seekNodes(seek);
+                }
+            }
+        }
+        if (!reusedChunk) {
+            (0, core_utils_1.assert)(cursor.mode === 0 /* CursorLocationType.Nodes */, 0x580 /* should be in nodes */);
+            // TODO: if provided, use schema to consider using UniformChunks
+            const type = cursor.type;
+            const shape = policy.shapeFromSchema(type);
+            if (shape instanceof uniformChunk_1.TreeShape) {
+                const nodesPerTopLevelNode = shape.positions.length;
+                const maxTopLevelLength = Math.ceil(nodesPerTopLevelNode / policy.uniformChunkNodeCount);
+                const maxLength = Math.min(maxTopLevelLength, remaining);
+                const newChunk = uniformChunkFromCursor(cursor, shape, maxLength, maxLength === remaining && skipLastNavigation);
+                remaining -= newChunk.topLevelLength;
+                output.push(newChunk);
+            }
+            else {
+                // Slow path: copy tree into new basic chunk
+                output.push(newBasicChunkTree(cursor, policy));
+                remaining -= 1;
+                if (!skipLastNavigation || remaining !== 0) {
+                    cursor.nextNode();
+                }
+            }
+        }
+    }
+    // TODO: maybe make a pass over output to coalesce UniformChunks and/or convert other formats to UniformChunks where possible.
+    // If output is large, group it into a tree of sequence chunks.
+    while (output.length > policy.sequenceChunkSplitThreshold) {
+        const chunkCount = Math.ceil(output.length / policy.sequenceChunkSplitThreshold);
+        const newOutput = [];
+        // Rounding down, and add an extra item to some of the chunks.
+        const chunkSize = Math.floor(output.length / chunkCount);
+        // number of chunks to add an extra item to to make total line up.
+        const extra = output.length % chunkCount;
+        let previousEnd = 0;
+        for (let index = 0; index < chunkCount; index++) {
+            // If we are in the first `extra` items, add an extra to this chunk.
+            const end = previousEnd + chunkSize + (index < extra ? 1 : 0);
+            newOutput.push(new sequenceChunk_1.SequenceChunk(output.slice(previousEnd, end)));
+            previousEnd = end;
+        }
+        (0, core_utils_1.assert)(previousEnd === output.length, 0x581 /* chunks should add up to total */);
+        output = newOutput;
+    }
+    return output;
+}
+exports.chunkRange = chunkRange;
+function insertValues(cursor, shape, values) {
+    (0, core_utils_1.assert)(shape.type === cursor.type, 0x582 /* shape and type must match */);
+    // TODO:Perf:
+    // Fast path for already part of a uniform chunk with matching shape
+    // Slow path: walk shape and cursor together, inserting values.
+    if (shape.hasValue) {
+        values.push(cursor.value);
+    }
+    for (const [key, childShape, length] of shape.fieldsArray) {
+        cursor.enterField(key);
+        let count = 0;
+        for (let inNodes = cursor.firstNode(); inNodes; inNodes = cursor.nextNode()) {
+            insertValues(cursor, childShape, values);
+            count++;
+        }
+        cursor.exitField();
+        (0, core_utils_1.assert)(length === count, 0x583 /* unexpected field length */);
+    }
+}
+exports.insertValues = insertValues;
+/**
+ * Read up to `maxTopLevelLength` nodes from `cursor`, stopping when limit is hit or type of node changes.
+ *
+ * This requires that the all trees with matching type match the provided shape.
+ * This cannot be used if other shapes are possible for this type.
+ *
+ * If this stops early due to the type changing, `skipLastNavigation` is not involved:
+ * `skipLastNavigation` only determines if the cursor will be left on the node after the last one (possibly exiting the field)
+ * if the full length is used.
+ */
+function uniformChunkFromCursor(cursor, shape, maxTopLevelLength, skipLastNavigation) {
+    // TODO:
+    // This could have a fast path for consuming already uniformly chunked data with matching shape.
+    const values = [];
+    let topLevelLength = 1;
+    while (topLevelLength <= maxTopLevelLength) {
+        insertValues(cursor, shape, values);
+        if (topLevelLength === maxTopLevelLength) {
+            if (!skipLastNavigation) {
+                cursor.nextNode();
+            }
+            break;
+        }
+        cursor.nextNode();
+        if (cursor.type !== shape.type) {
+            break;
+        }
+        topLevelLength += 1;
+    }
+    return new uniformChunk_1.UniformChunk(shape.withTopLevelLength(topLevelLength), values);
+}
+exports.uniformChunkFromCursor = uniformChunkFromCursor;
+//# sourceMappingURL=chunkTree.js.map

package/dist/feature-libraries/chunked-forest/chunkTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkTree.js","sourceRoot":"","sources":["../../../src/feature-libraries/chunked-forest/chunkTree.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\tTreeFieldStoredSchema,\n\tITreeCursorSynchronous,\n\tmapCursorFields,\n\tTreeNodeSchemaIdentifier,\n\tValue,\n\tTreeValue,\n\tTreeStoredSchemaSubscription,\n\tCursorLocationType,\n\tTreeStoredSchema,\n\tStoredSchemaCollection,\n\tLeafNodeStoredSchema,\n\tObjectNodeStoredSchema,\n} from \"../../core\";\nimport { FullSchemaPolicy } from \"../modular-schema\";\nimport { fail, getOrCreate } from \"../../util\";\nimport { Multiplicity } from \"../multiplicity\";\nimport { TreeChunk, tryGetChunk } from \"./chunk\";\nimport { BasicChunk } from \"./basicChunk\";\nimport { FieldShape, TreeShape, UniformChunk } from \"./uniformChunk\";\nimport { SequenceChunk } from \"./sequenceChunk\";\n\nexport interface Disposable {\n\t/**\n\t * Cleans up resources used by this, such as inbound event registrations.\n\t */\n\tdispose(): void;\n}\n\n/**\n * Creates a ChunkPolicy which responds to schema changes.\n */\nexport function makeTreeChunker(\n\tschema: TreeStoredSchemaSubscription,\n\tpolicy: FullSchemaPolicy,\n): IChunker {\n\treturn new Chunker(\n\t\tschema,\n\t\tpolicy,\n\t\tdefaultChunkPolicy.sequenceChunkInlineThreshold,\n\t\tdefaultChunkPolicy.sequenceChunkInlineThreshold,\n\t\tdefaultChunkPolicy.uniformChunkNodeCount,\n\t\ttryShapeFromSchema,\n\t);\n}\n\n/**\n * Extends ChunkPolicy to include stateful details required by ChunkedForest.\n *\n * This extra complexity is mostly due to the fact that schema can change over time,\n * and that chunk policy uses caching which thus needs invalidation.\n */\nexport interface IChunker extends ChunkPolicy, Disposable {\n\treadonly schema: TreeStoredSchemaSubscription;\n\tclone(schema: TreeStoredSchemaSubscription): IChunker;\n}\n\n/**\n * Indicates that there are multiple possible `TreeShape` trees with a given type can have.\n *\n * @remarks\n * For example, a schema transitively containing a sequence field, optional field, or allowing multiple child types will be Polymorphic.\n * See `tryShapeFromSchema` for how to tell if a type is Polymorphic.\n *\n * TODO: cache some of the possible shapes here.\n */\n// eslint-disable-next-line @typescript-eslint/no-extraneous-class\nexport class Polymorphic {}\n\n/**\n * See `Polymorphic`.\n * For now Polymorphic is stateless, so just use a singleton.\n */\nexport const polymorphic = new Polymorphic();\n\n/**\n * Information about the possible shapes a tree could take based on its type.\n * Note that this information is for a specific version of the schema.\n */\nexport type ShapeInfo = TreeShape | Polymorphic;\n\nexport class Chunker implements IChunker {\n\t/**\n\t * Cache for information about possible shapes for types.\n\t * Corresponds to the version of the schema in `schema`.\n\t * Cleared when `schema` changes.\n\t */\n\tprivate readonly typeShapes: Map<TreeNodeSchemaIdentifier, ShapeInfo> = new Map();\n\n\tprivate unregisterSchemaCallback: (() => void) | undefined;\n\n\tpublic constructor(\n\t\tpublic readonly schema: TreeStoredSchemaSubscription,\n\t\tpublic readonly policy: FullSchemaPolicy,\n\t\tpublic readonly sequenceChunkSplitThreshold: number,\n\t\tpublic readonly sequenceChunkInlineThreshold: number,\n\t\tpublic readonly uniformChunkNodeCount: number,\n\t\t// eslint-disable-next-line @typescript-eslint/no-shadow\n\t\tprivate readonly tryShapeFromSchema: (\n\t\t\tschema: TreeStoredSchema,\n\t\t\tpolicy: FullSchemaPolicy,\n\t\t\ttype: TreeNodeSchemaIdentifier,\n\t\t\tshapes: Map<TreeNodeSchemaIdentifier, ShapeInfo>,\n\t\t) => ShapeInfo,\n\t) {}\n\n\tpublic clone(schema: TreeStoredSchemaSubscription): IChunker {\n\t\t// This does not preserve the cache.\n\t\t// This is probably fine, but is a potential way it could be optimized in the future (with care to ensure invalidation work properly).\n\t\treturn new Chunker(\n\t\t\tschema,\n\t\t\tthis.policy,\n\t\t\tthis.sequenceChunkSplitThreshold,\n\t\t\tthis.sequenceChunkInlineThreshold,\n\t\t\tthis.uniformChunkNodeCount,\n\t\t\tthis.tryShapeFromSchema,\n\t\t);\n\t}\n\n\tpublic shapeFromSchema(schema: TreeNodeSchemaIdentifier): ShapeInfo {\n\t\tconst cached = this.typeShapes.get(schema);\n\t\tif (cached !== undefined) {\n\t\t\treturn cached;\n\t\t}\n\t\tthis.unregisterSchemaCallback = this.schema.on(\"afterSchemaChange\", () =>\n\t\t\tthis.schemaChanged(),\n\t\t);\n\t\treturn this.tryShapeFromSchema(this.schema, this.policy, schema, this.typeShapes);\n\t}\n\n\tpublic dispose(): void {\n\t\t// Remove subscription for changes via dependent.\n\t\tthis.schemaChanged();\n\t}\n\n\tprivate schemaChanged(): void {\n\t\tthis.typeShapes.clear();\n\t\tif (this.unregisterSchemaCallback) {\n\t\t\tthis.unregisterSchemaCallback();\n\t\t\tthis.unregisterSchemaCallback = undefined;\n\t\t}\n\t}\n}\n\n/**\n * Get a TreeChunk for the current node (and its children) of cursor.\n * This will copy if needed, but add refs to existing chunks which hold the data.\n *\n * @param cursor - cursor in nodes mode\n */\nexport function chunkTree(cursor: ITreeCursorSynchronous, policy: ChunkPolicy): TreeChunk {\n\treturn chunkRange(cursor, policy, 1, true)[0];\n}\n\n/**\n * Get a TreeChunk[] for the current field (and its children) of cursor.\n * This will copy if needed, but add refs to existing chunks which hold the data.\n */\nexport function chunkField(cursor: ITreeCursorSynchronous, policy: ChunkPolicy): TreeChunk[] {\n\tconst length = cursor.getFieldLength();\n\tconst started = cursor.firstNode();\n\tassert(started, 0x57c /* field to chunk should have at least one node */);\n\treturn chunkRange(cursor, policy, length, false);\n}\n\n/**\n * Get a TreeChunk for the current field (and its children) of cursor.\n * Like {@link chunkField}, but forces the results into a single TreeChunk.\n */\nexport function chunkFieldSingle(cursor: ITreeCursorSynchronous, policy: ChunkPolicy): TreeChunk {\n\tconst chunks = chunkField(cursor, policy);\n\tif (chunks.length === 1) {\n\t\treturn chunks[0];\n\t}\n\treturn new SequenceChunk(chunks);\n}\n\n/**\n * Get a BasicChunk for the current node (and its children) of cursor.\n * This will copy if needed, and add refs to existing chunks which hold the data.\n */\nexport function basicChunkTree(cursor: ITreeCursorSynchronous, policy: ChunkPolicy): BasicChunk {\n\t// symbol based fast path to check for BasicChunk:\n\t// return existing chunk with a increased ref count if possible.\n\tconst chunk = tryGetChunk(cursor);\n\tif (chunk instanceof BasicChunk) {\n\t\tchunk.referenceAdded();\n\t\treturn chunk;\n\t}\n\n\treturn newBasicChunkTree(cursor, policy);\n}\n\nexport function makePolicy(policy?: Partial<ChunkPolicy>): ChunkPolicy {\n\tconst withDefaults = { ...defaultChunkPolicy, ...policy };\n\t// TODO: move this to a top level policy validation\n\tassert(\n\t\twithDefaults.sequenceChunkSplitThreshold >= 2,\n\t\t0x57d /* sequenceChunkThreshold must be at least 2 */,\n\t);\n\n\treturn withDefaults;\n}\n\nexport function shapesFromSchema(\n\tschema: StoredSchemaCollection,\n\tpolicy: FullSchemaPolicy,\n): Map<TreeNodeSchemaIdentifier, ShapeInfo> {\n\tconst shapes: Map<TreeNodeSchemaIdentifier, ShapeInfo> = new Map();\n\tfor (const identifier of schema.nodeSchema.keys()) {\n\t\ttryShapeFromSchema(schema, policy, identifier, shapes);\n\t}\n\treturn shapes;\n}\n\n/**\n * If `schema` has only one shape, return it.\n *\n * Note that this does not tolerate optional or sequence fields, nor does it optimize for patterns of specific values.\n */\nexport function tryShapeFromSchema(\n\tschema: StoredSchemaCollection,\n\tpolicy: FullSchemaPolicy,\n\ttype: TreeNodeSchemaIdentifier,\n\tshapes: Map<TreeNodeSchemaIdentifier, ShapeInfo>,\n): ShapeInfo {\n\treturn getOrCreate(shapes, type, () => {\n\t\tconst treeSchema = schema.nodeSchema.get(type) ?? fail(\"missing schema\");\n\t\tif (treeSchema instanceof LeafNodeStoredSchema) {\n\t\t\treturn new TreeShape(type, true, []);\n\t\t}\n\t\tif (treeSchema instanceof ObjectNodeStoredSchema) {\n\t\t\tconst fieldsArray: FieldShape[] = [];\n\t\t\tfor (const [key, field] of treeSchema.objectNodeFields) {\n\t\t\t\tconst fieldShape = tryShapeFromFieldSchema(schema, policy, field, key, shapes);\n\t\t\t\tif (fieldShape === undefined) {\n\t\t\t\t\treturn polymorphic;\n\t\t\t\t}\n\t\t\t\tfieldsArray.push(fieldShape);\n\t\t\t}\n\t\t\treturn new TreeShape(type, false, fieldsArray);\n\t\t}\n\t\treturn polymorphic;\n\t});\n}\n\n/**\n * If `schema` has only one shape, return it.\n *\n * Note that this does not tolerate optional or sequence fields, nor does it optimize for patterns of specific values.\n */\nexport function tryShapeFromFieldSchema(\n\tschema: StoredSchemaCollection,\n\tpolicy: FullSchemaPolicy,\n\ttype: TreeFieldStoredSchema,\n\tkey: FieldKey,\n\tshapes: Map<TreeNodeSchemaIdentifier, ShapeInfo>,\n): FieldShape | undefined {\n\tconst kind = policy.fieldKinds.get(type.kind.identifier) ?? fail(\"missing FieldKind\");\n\tif (kind.multiplicity !== Multiplicity.Single) {\n\t\treturn undefined;\n\t}\n\tif (type.types?.size !== 1) {\n\t\treturn undefined;\n\t}\n\tconst childType = [...type.types][0];\n\tconst childShape = tryShapeFromSchema(schema, policy, childType, shapes);\n\tif (childShape instanceof Polymorphic) {\n\t\treturn undefined;\n\t}\n\treturn [key, childShape, 1];\n}\n\n/**\n * Default settings for use for {@link ChunkPolicy}.\n * Use `makeTreeChunker` to create a policy with the defaults, but leverages to schema.\n */\nexport const defaultChunkPolicy: ChunkPolicy = {\n\t// Currently ChunkedForest and BasicTreeCursor don't handle SequenceChunks very efficiently:\n\t// they likely add more overhead than they save for now, so don't create them.\n\tsequenceChunkSplitThreshold: Number.POSITIVE_INFINITY,\n\tsequenceChunkInlineThreshold: Number.POSITIVE_INFINITY,\n\t// Current UniformChunk handling doesn't scale well to large chunks, so set a modest size limit:\n\tuniformChunkNodeCount: 400,\n\t// Without knowing what the schema is, all shapes are possible.\n\t// Use `makeTreeChunker` to do better.\n\tshapeFromSchema: () => polymorphic,\n};\n\nexport const basicOnlyChunkPolicy: ChunkPolicy = {\n\tsequenceChunkSplitThreshold: Number.POSITIVE_INFINITY,\n\tsequenceChunkInlineThreshold: Number.POSITIVE_INFINITY,\n\tuniformChunkNodeCount: 0,\n\tshapeFromSchema: () => polymorphic,\n};\n\n/**\n * Policy for how to chunk a tree.\n */\nexport interface ChunkPolicy {\n\t/**\n\t * Group sequences longer than this into into sequence chunks of this length or less.\n\t *\n\t * Must be at least 2.\n\t * Can be set to `Number.POSITIVE_INFINITY` to never introduce extra sequence chunks.\n\t */\n\treadonly sequenceChunkSplitThreshold: number;\n\n\t/**\n\t * SequenceChunks this long or shorter may get inlined into their parent chunk.\n\t */\n\treadonly sequenceChunkInlineThreshold: number;\n\n\t/**\n\t * Maximum total nodes to put in a UniformChunk.\n\t */\n\treadonly uniformChunkNodeCount: number;\n\n\t/**\n\t * Returns information about the shapes trees of type `schema` can take.\n\t */\n\tshapeFromSchema(schema: TreeNodeSchemaIdentifier): ShapeInfo;\n}\n\nfunction newBasicChunkTree(cursor: ITreeCursorSynchronous, policy: ChunkPolicy): BasicChunk {\n\treturn new BasicChunk(\n\t\tcursor.type,\n\t\tnew Map(mapCursorFields(cursor, () => [cursor.getFieldKey(), chunkField(cursor, policy)])),\n\t\tcursor.value,\n\t);\n}\n\n/**\n * @param cursor - cursor in nodes mode\n * @param policy - heuristics to impact chunking\n * @param length - how many nodes to process (at the top level)\n * @param skipLastNavigation - if true, leaves the cursor at the last node instead of moving off of it.\n */\nexport function chunkRange(\n\tcursor: ITreeCursorSynchronous,\n\tpolicy: ChunkPolicy,\n\tlength: number,\n\tskipLastNavigation: boolean,\n): TreeChunk[] {\n\tassert(cursor.mode === CursorLocationType.Nodes, 0x57e /* should be in nodes */);\n\tlet output: TreeChunk[] = [];\n\tlet remaining = length;\n\twhile (remaining > 0) {\n\t\tassert(cursor.mode === CursorLocationType.Nodes, 0x57f /* should be in nodes */);\n\t\tconst start = cursor.chunkStart;\n\t\tlet reusedChunk = false;\n\t\t// symbol based fast path to check for chunk:\n\t\t// return existing chunk with a increased ref count if possible.\n\t\tif (start === cursor.fieldIndex) {\n\t\t\tconst chunkLength = cursor.chunkLength;\n\t\t\tif (chunkLength <= remaining) {\n\t\t\t\tconst chunk = tryGetChunk(cursor);\n\t\t\t\tif (chunk !== undefined) {\n\t\t\t\t\tif (\n\t\t\t\t\t\tchunk instanceof SequenceChunk &&\n\t\t\t\t\t\tchunk.subChunks.length <= policy.sequenceChunkInlineThreshold\n\t\t\t\t\t) {\n\t\t\t\t\t\t// If sequence chunk, and its very short, inline it.\n\t\t\t\t\t\t// Note that this is not recursive: there may be short sequences nested below this which are not inlined.\n\t\t\t\t\t\tfor (const subChunk of chunk.subChunks) {\n\t\t\t\t\t\t\tsubChunk.referenceAdded();\n\t\t\t\t\t\t\toutput.push(subChunk);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tchunk.referenceAdded();\n\t\t\t\t\toutput.push(chunk);\n\t\t\t\t\tremaining -= chunkLength;\n\t\t\t\t\treusedChunk = true;\n\t\t\t\t\tlet seek = chunkLength;\n\t\t\t\t\tif (skipLastNavigation && remaining === 0) {\n\t\t\t\t\t\tseek -= 1;\n\t\t\t\t\t}\n\t\t\t\t\tcursor.seekNodes(seek);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (!reusedChunk) {\n\t\t\tassert(cursor.mode === CursorLocationType.Nodes, 0x580 /* should be in nodes */);\n\t\t\t// TODO: if provided, use schema to consider using UniformChunks\n\t\t\tconst type = cursor.type;\n\t\t\tconst shape = policy.shapeFromSchema(type);\n\t\t\tif (shape instanceof TreeShape) {\n\t\t\t\tconst nodesPerTopLevelNode = shape.positions.length;\n\t\t\t\tconst maxTopLevelLength = Math.ceil(\n\t\t\t\t\tnodesPerTopLevelNode / policy.uniformChunkNodeCount,\n\t\t\t\t);\n\t\t\t\tconst maxLength = Math.min(maxTopLevelLength, remaining);\n\t\t\t\tconst newChunk = uniformChunkFromCursor(\n\t\t\t\t\tcursor,\n\t\t\t\t\tshape,\n\t\t\t\t\tmaxLength,\n\t\t\t\t\tmaxLength === remaining && skipLastNavigation,\n\t\t\t\t);\n\t\t\t\tremaining -= newChunk.topLevelLength;\n\t\t\t\toutput.push(newChunk);\n\t\t\t} else {\n\t\t\t\t// Slow path: copy tree into new basic chunk\n\t\t\t\toutput.push(newBasicChunkTree(cursor, policy));\n\t\t\t\tremaining -= 1;\n\t\t\t\tif (!skipLastNavigation || remaining !== 0) {\n\t\t\t\t\tcursor.nextNode();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// TODO: maybe make a pass over output to coalesce UniformChunks and/or convert other formats to UniformChunks where possible.\n\n\t// If output is large, group it into a tree of sequence chunks.\n\twhile (output.length > policy.sequenceChunkSplitThreshold) {\n\t\tconst chunkCount = Math.ceil(output.length / policy.sequenceChunkSplitThreshold);\n\t\tconst newOutput: TreeChunk[] = [];\n\t\t// Rounding down, and add an extra item to some of the chunks.\n\t\tconst chunkSize = Math.floor(output.length / chunkCount);\n\t\t// number of chunks to add an extra item to to make total line up.\n\t\tconst extra = output.length % chunkCount;\n\t\tlet previousEnd = 0;\n\t\tfor (let index = 0; index < chunkCount; index++) {\n\t\t\t// If we are in the first `extra` items, add an extra to this chunk.\n\t\t\tconst end = previousEnd + chunkSize + (index < extra ? 1 : 0);\n\t\t\tnewOutput.push(new SequenceChunk(output.slice(previousEnd, end)));\n\t\t\tpreviousEnd = end;\n\t\t}\n\t\tassert(previousEnd === output.length, 0x581 /* chunks should add up to total */);\n\t\toutput = newOutput;\n\t}\n\n\treturn output;\n}\n\nexport function insertValues(\n\tcursor: ITreeCursorSynchronous,\n\tshape: TreeShape,\n\tvalues: Value[],\n): void {\n\tassert(shape.type === cursor.type, 0x582 /* shape and type must match */);\n\n\t// TODO:Perf:\n\t// Fast path for already part of a uniform chunk with matching shape\n\n\t// Slow path: walk shape and cursor together, inserting values.\n\tif (shape.hasValue) {\n\t\tvalues.push(cursor.value);\n\t}\n\tfor (const [key, childShape, length] of shape.fieldsArray) {\n\t\tcursor.enterField(key);\n\t\tlet count = 0;\n\t\tfor (let inNodes = cursor.firstNode(); inNodes; inNodes = cursor.nextNode()) {\n\t\t\tinsertValues(cursor, childShape, values);\n\t\t\tcount++;\n\t\t}\n\t\tcursor.exitField();\n\t\tassert(length === count, 0x583 /* unexpected field length */);\n\t}\n}\n\n/**\n * Read up to `maxTopLevelLength` nodes from `cursor`, stopping when limit is hit or type of node changes.\n *\n * This requires that the all trees with matching type match the provided shape.\n * This cannot be used if other shapes are possible for this type.\n *\n * If this stops early due to the type changing, `skipLastNavigation` is not involved:\n * `skipLastNavigation` only determines if the cursor will be left on the node after the last one (possibly exiting the field)\n * if the full length is used.\n */\nexport function uniformChunkFromCursor(\n\tcursor: ITreeCursorSynchronous,\n\tshape: TreeShape,\n\tmaxTopLevelLength: number,\n\tskipLastNavigation: boolean,\n): UniformChunk {\n\t// TODO:\n\t// This could have a fast path for consuming already uniformly chunked data with matching shape.\n\n\tconst values: TreeValue[] = [];\n\tlet topLevelLength = 1;\n\twhile (topLevelLength <= maxTopLevelLength) {\n\t\tinsertValues(cursor, shape, values);\n\t\tif (topLevelLength === maxTopLevelLength) {\n\t\t\tif (!skipLastNavigation) {\n\t\t\t\tcursor.nextNode();\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\tcursor.nextNode();\n\t\tif (cursor.type !== shape.type) {\n\t\t\tbreak;\n\t\t}\n\t\ttopLevelLength += 1;\n\t}\n\treturn new UniformChunk(shape.withTopLevelLength(topLevelLength), values);\n}\n"]}

package/dist/feature-libraries/chunked-forest/chunkedForest.d.ts

@@ -0,0 +1,57 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { ITreeSubscriptionCursor, IEditableForest, TreeNavigationResult, TreeStoredSchemaSubscription, FieldKey, DetachedField, AnchorSet, UpPath, Anchor, FieldAnchor, ForestEvents, ITreeSubscriptionCursorState, DeltaVisitor, ITreeCursorSynchronous } from "../../core";
+import { BasicChunk, BasicChunkCursor, SiblingsOrKey } from "./basicChunk";
+import { IChunker } from "./chunkTree";
+import { ChunkedCursor, TreeChunk } from "./chunk";
+/**
+ * Implementation of IEditableForest based on copy on write chunks.
+ *
+ * This implementation focuses on performance.
+ */
+export declare class ChunkedForest implements IEditableForest {
+    roots: BasicChunk;
+    readonly schema: TreeStoredSchemaSubscription;
+    readonly chunker: IChunker;
+    readonly anchors: AnchorSet;
+    private activeVisitor?;
+    private readonly events;
+    /**
+     * @param roots - dummy node above the root under which detached fields are stored. All content of the forest is reachable from this.
+     * @param schema - schema which all content in this forest is assumed to comply with.
+     * @param chunker - Chunking policy. TODO: dispose of this when forest is disposed.
+     * @param anchors - anchorSet used to track location in this forest across changes. Callers of applyDelta must ensure this is updated accordingly.
+     */
+    constructor(roots: BasicChunk, schema: TreeStoredSchemaSubscription, chunker: IChunker, anchors?: AnchorSet);
+    get isEmpty(): boolean;
+    on<K extends keyof ForestEvents>(eventName: K, listener: ForestEvents[K]): () => void;
+    clone(schema: TreeStoredSchemaSubscription, anchors: AnchorSet): ChunkedForest;
+    forgetAnchor(anchor: Anchor): void;
+    acquireVisitor(): DeltaVisitor;
+    private nextDetachedFieldIdentifier;
+    newDetachedField(): DetachedField;
+    allocateCursor(): Cursor;
+    tryMoveCursorToNode(destination: Anchor, cursorToMove: ITreeSubscriptionCursor): TreeNavigationResult;
+    tryMoveCursorToField(destination: FieldAnchor, cursorToMove: ITreeSubscriptionCursor): TreeNavigationResult;
+    moveCursorToPath(destination: UpPath, cursorToMove: ITreeSubscriptionCursor): void;
+    getCursorAboveDetachedFields(): ITreeCursorSynchronous;
+}
+declare class Cursor extends BasicChunkCursor implements ITreeSubscriptionCursor {
+    readonly forest: ChunkedForest;
+    state: ITreeSubscriptionCursorState;
+    constructor(forest: ChunkedForest, state: ITreeSubscriptionCursorState, root: readonly TreeChunk[], siblingStack: SiblingsOrKey[], indexStack: number[], indexOfChunkStack: number[], indexWithinChunkStack: number[], siblings: SiblingsOrKey, index: number, indexOfChunk: number, indexWithinChunk: number, nestedCursor: ChunkedCursor | undefined);
+    setToDetachedSequence(key: FieldKey): void;
+    fork(): Cursor;
+    buildFieldAnchor(): FieldAnchor;
+    free(): void;
+    buildAnchor(): Anchor;
+    clear(): void;
+}
+/**
+ * @returns an implementation of {@link IEditableForest} with no data or schema.
+ */
+export declare function buildChunkedForest(chunker: IChunker, anchors?: AnchorSet): ChunkedForest;
+export {};
+//# sourceMappingURL=chunkedForest.d.ts.map