@fluidframework/tree 2.3.0-288113 → 2.3.1

package/lib/events/listeners.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"listeners.js","sourceRoot":"","sources":["../../src/events/listeners.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * `true` iff the given type is an acceptable shape for a {@link Listeners | event} listener\n * @public\n */\nexport type IsListener<TListener> = TListener extends (...args: any[]) => void ? true : false;\n\n/**\n * Used to specify the kinds of events emitted by a {@link Listenable}.\n *\n * @remarks\n * Any object type is a valid {@link Listeners}, but only the {@link IsListener | event-like} properties of that\n * type will be included.\n *\n * @example\n * ```typescript\n * interface MyEvents {\n *   load: (user: string, data: IUserData) => void;\n *   error: (errorCode: number) => void;\n * }\n * ```\n *\n * @public\n */\nexport type Listeners<T extends object> = {\n\t[P in (string | symbol) & keyof T as IsListener<T[P]> extends true ? P : never]: T[P];\n};\n\n/**\n * An object which allows the registration of listeners so that subscribers can be notified when an event happens.\n * @param TListeners - All the {@link Listeners | events} that this subscribable supports\n *\n * @privateRemarks\n * `EventEmitter` can be used as a base class to implement this via extension.\n * ```ts\n * type MyEventEmitter = IEventEmitter<{\n *   load: (user: string, data: IUserData) => void;\n *   error: (errorCode: number) => void;\n * }>\n * ```\n * {@link createEmitter} can help implement this interface via delegation.\n *\n * @sealed @public\n */\nexport interface Listenable<TListeners extends object> {\n\t/**\n\t * Register an event listener.\n\t * @param eventName - The name of the event.\n\t * @param listener - the handler to run when the event is fired by the emitter\n\t * @returns a {@link Off | function} which will deregister the listener when called.\n\t * This deregistration function is idempotent and therefore may be safely called more than once with no effect.\n\t * @remarks Do not register the exact same `listener` object for the same event more than once.\n\t * Doing so will result in undefined behavior, and is not guaranteed to behave the same in future versions of this library.\n\t */\n\ton<K extends keyof Listeners<TListeners>>(eventName: K, listener: TListeners[K]): Off;\n}\n\n/**\n * A function that, when called, will deregister an event listener subscription that was previously registered.\n * @remarks\n * It is returned by the {@link Listenable.on | event registration function} when event registration occurs.\n * @public\n */\nexport type Off = () => void;\n"]}

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

@@ -7,6 +7,7 @@ import type { FullSchemaPolicy } from "../modular-schema/index.js";
 import { BasicChunk } from "./basicChunk.js";
 import { type TreeChunk } from "./chunk.js";
 import { type FieldShape, TreeShape, UniformChunk } from "./uniformChunk.js";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 export interface Disposable {
     /**
      * Cleans up resources used by this, such as inbound event registrations.
@@ -74,22 +75,22 @@ export declare class Chunker implements IChunker {
  *
  * @param cursor - cursor in nodes mode
  */
-export declare function chunkTree(cursor: ITreeCursorSynchronous, policy: ChunkPolicy): TreeChunk;
+export declare function chunkTree(cursor: ITreeCursorSynchronous, policy: ChunkCompressor): 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[];
+export declare function chunkField(cursor: ITreeCursorSynchronous, policy: ChunkCompressor): 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;
+export declare function chunkFieldSingle(cursor: ITreeCursorSynchronous, policy: ChunkCompressor): 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 basicChunkTree(cursor: ITreeCursorSynchronous, policy: ChunkCompressor): BasicChunk;
 export declare function makePolicy(policy?: Partial<ChunkPolicy>): ChunkPolicy;
 export declare function shapesFromSchema(schema: StoredSchemaCollection, policy: FullSchemaPolicy): Map<TreeNodeSchemaIdentifier, ShapeInfo>;
 /**
@@ -134,14 +135,28 @@ export interface ChunkPolicy {
      */
     shapeFromSchema(schema: TreeNodeSchemaIdentifier): ShapeInfo;
 }
+export interface ChunkCompressor {
+    readonly policy: ChunkPolicy;
+    /**
+     * If the idCompressor is provided, {@link UniformChunk}s with identifiers will be encoded for its in-memory representation.
+     * @remarks
+     * This compression applies to {@link UniformChunk}s when {@link TreeShape.maybeDecompressedStringAsNumber} is set.
+     * If the `policy` does not use UniformChunks or does not set `maybeDecompressedStringAsNumber`, then no compression will be applied even when providing `idCompressor`.
+     */
+    readonly idCompressor: IIdCompressor | undefined;
+}
 /**
  * @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;
+export declare function chunkRange(cursor: ITreeCursorSynchronous, chunkCompressor: ChunkCompressor, length: number, skipLastNavigation: boolean): TreeChunk[];
+/**
+ * @param idCompressor - compressor used to encoded string values that are compressible by the idCompressor for in-memory representation.
+ * If the idCompressor is not provided, the values will be the original uncompressed values.
+ */
+export declare function insertValues(cursor: ITreeCursorSynchronous, shape: TreeShape, values: Value[], idCompressor?: IIdCompressor): void;
 /**
  * Read up to `maxTopLevelLength` nodes from `cursor`, stopping when limit is hit or type of node changes.
  *
@@ -151,6 +166,9 @@ export declare function insertValues(cursor: ITreeCursorSynchronous, shape: Tree
  * 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.
+ *
+ * @param idCompressor - compressor used to encoded string values that are compressible by the idCompressor for in-memory representation.
+ * If the idCompressor is not provided, the values will be the original uncompressed values.
  */
-export declare function uniformChunkFromCursor(cursor: ITreeCursorSynchronous, shape: TreeShape, maxTopLevelLength: number, skipLastNavigation: boolean): UniformChunk;
+export declare function uniformChunkFromCursor(cursor: ITreeCursorSynchronous, shape: TreeShape, maxTopLevelLength: number, skipLastNavigation: boolean, idCompressor?: IIdCompressor): UniformChunk;
 //# sourceMappingURL=chunkTree.d.ts.map

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

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

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

@@ -3,12 +3,13 @@
  * Licensed under the MIT License.
  */
 import { assert, oob } from "@fluidframework/core-utils/internal";
-import { LeafNodeStoredSchema, ObjectNodeStoredSchema, mapCursorFields, Multiplicity, } from "../../core/index.js";
+import { LeafNodeStoredSchema, ObjectNodeStoredSchema, mapCursorFields, Multiplicity, ValueSchema, } from "../../core/index.js";
 import { fail, getOrCreate } from "../../util/index.js";
 import { BasicChunk } from "./basicChunk.js";
 import { tryGetChunk } from "./chunk.js";
 import { SequenceChunk } from "./sequenceChunk.js";
 import { TreeShape, UniformChunk } from "./uniformChunk.js";
+import { isStableNodeKey } from "../node-key/index.js";
 /**
  * Creates a ChunkPolicy which responds to schema changes.
  */
@@ -140,7 +141,13 @@ export function tryShapeFromSchema(schema, policy, type, shapes) {
     return getOrCreate(shapes, type, () => {
         const treeSchema = schema.nodeSchema.get(type) ?? fail("missing schema");
         if (treeSchema instanceof LeafNodeStoredSchema) {
-            return new TreeShape(type, true, []);
+            // Allow all string values (but only string values) to be compressed by the id compressor.
+            // This allows compressing all compressible identifiers without requiring additional context to know which values could be identifiers.
+            // Attempting to compress other string shouldn't have significant overhead,
+            // and if any of them do end up compressing, that's a benefit not a bug.
+            return treeSchema.leafValue === ValueSchema.String
+                ? new TreeShape(type, true, [], true)
+                : new TreeShape(type, true, [], false);
         }
         if (treeSchema instanceof ObjectNodeStoredSchema) {
             const fieldsArray = [];
@@ -206,7 +213,7 @@ function newBasicChunkTree(cursor, policy) {
  * @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 function chunkRange(cursor, policy, length, skipLastNavigation) {
+export function chunkRange(cursor, chunkCompressor, length, skipLastNavigation) {
     assert(cursor.mode === 0 /* CursorLocationType.Nodes */, 0x57e /* should be in nodes */);
     let output = [];
     let remaining = length;
@@ -222,7 +229,7 @@ export function chunkRange(cursor, policy, length, skipLastNavigation) {
                 const chunk = tryGetChunk(cursor);
                 if (chunk !== undefined) {
                     if (chunk instanceof SequenceChunk &&
-                        chunk.subChunks.length <= policy.sequenceChunkInlineThreshold) {
+                        chunk.subChunks.length <= chunkCompressor.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) {
@@ -246,18 +253,18 @@ export function chunkRange(cursor, policy, length, skipLastNavigation) {
             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);
+            const shape = chunkCompressor.policy.shapeFromSchema(type);
             if (shape instanceof TreeShape) {
                 const nodesPerTopLevelNode = shape.positions.length;
-                const maxTopLevelLength = Math.ceil(nodesPerTopLevelNode / policy.uniformChunkNodeCount);
+                const maxTopLevelLength = Math.ceil(nodesPerTopLevelNode / chunkCompressor.policy.uniformChunkNodeCount);
                 const maxLength = Math.min(maxTopLevelLength, remaining);
-                const newChunk = uniformChunkFromCursor(cursor, shape, maxLength, maxLength === remaining && skipLastNavigation);
+                const newChunk = uniformChunkFromCursor(cursor, shape, maxLength, maxLength === remaining && skipLastNavigation, chunkCompressor.idCompressor);
                 remaining -= newChunk.topLevelLength;
                 output.push(newChunk);
             }
             else {
                 // Slow path: copy tree into new basic chunk
-                output.push(newBasicChunkTree(cursor, policy));
+                output.push(newBasicChunkTree(cursor, chunkCompressor));
                 remaining -= 1;
                 if (!skipLastNavigation || remaining !== 0) {
                     cursor.nextNode();
@@ -267,8 +274,8 @@ export function chunkRange(cursor, policy, length, skipLastNavigation) {
     }
     // 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);
+    while (output.length > chunkCompressor.policy.sequenceChunkSplitThreshold) {
+        const chunkCount = Math.ceil(output.length / chunkCompressor.policy.sequenceChunkSplitThreshold);
         const newOutput = [];
         // Rounding down, and add an extra item to some of the chunks.
         const chunkSize = Math.floor(output.length / chunkCount);
@@ -286,19 +293,30 @@ export function chunkRange(cursor, policy, length, skipLastNavigation) {
     }
     return output;
 }
-export function insertValues(cursor, shape, values) {
+/**
+ * @param idCompressor - compressor used to encoded string values that are compressible by the idCompressor for in-memory representation.
+ * If the idCompressor is not provided, the values will be the original uncompressed values.
+ */
+export function insertValues(cursor, shape, values, idCompressor) {
     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);
+        if (typeof cursor.value === "string" &&
+            idCompressor !== undefined &&
+            isStableNodeKey(cursor.value)) {
+            values.push(idCompressor.tryRecompress(cursor.value) ?? cursor.value);
+        }
+        else {
+            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);
+            insertValues(cursor, childShape, values, idCompressor);
             count++;
         }
         cursor.exitField();
@@ -314,14 +332,17 @@ export function insertValues(cursor, shape, values) {
  * 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.
+ *
+ * @param idCompressor - compressor used to encoded string values that are compressible by the idCompressor for in-memory representation.
+ * If the idCompressor is not provided, the values will be the original uncompressed values.
  */
-export function uniformChunkFromCursor(cursor, shape, maxTopLevelLength, skipLastNavigation) {
+export function uniformChunkFromCursor(cursor, shape, maxTopLevelLength, skipLastNavigation, idCompressor) {
     // 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);
+        insertValues(cursor, shape, values, idCompressor);
         if (topLevelLength === maxTopLevelLength) {
             if (!skipLastNavigation) {
                 cursor.nextNode();
@@ -334,6 +355,6 @@ export function uniformChunkFromCursor(cursor, shape, maxTopLevelLength, skipLas
         }
         topLevelLength += 1;
     }
-    return new UniformChunk(shape.withTopLevelLength(topLevelLength), values);
+    return new UniformChunk(shape.withTopLevelLength(topLevelLength), values, idCompressor);
 }
 //# sourceMappingURL=chunkTree.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"chunkTree.js","sourceRoot":"","sources":["../../../src/feature-libraries/chunked-forest/chunkTree.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,qCAAqC,CAAC;AAElE,OAAO,EAIN,oBAAoB,EACpB,sBAAsB,EAQtB,eAAe,EACf,YAAY,GACZ,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGxD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAkB,WAAW,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAmB,SAAS,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAS7E;;GAEG;AACH,MAAM,UAAU,eAAe,CAC9B,MAAoC,EACpC,MAAwB;IAExB,OAAO,IAAI,OAAO,CACjB,MAAM,EACN,MAAM,EACN,kBAAkB,CAAC,4BAA4B,EAC/C,kBAAkB,CAAC,4BAA4B,EAC/C,kBAAkB,CAAC,qBAAqB,EACxC,kBAAkB,CAClB,CAAC;AACH,CAAC;AAaD;;;;;;;;GAQG;AACH,kEAAkE;AAClE,MAAM,OAAO,WAAW;CAAG;AAE3B;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,IAAI,WAAW,EAAE,CAAC;AAQ7C,MAAM,OAAO,OAAO;IAUnB,YACiB,MAAoC,EACpC,MAAwB,EACxB,2BAAmC,EACnC,4BAAoC,EACpC,qBAA6B;IAC7C,wDAAwD;IACvC,kBAKH;QAXE,WAAM,GAAN,MAAM,CAA8B;QACpC,WAAM,GAAN,MAAM,CAAkB;QACxB,gCAA2B,GAA3B,2BAA2B,CAAQ;QACnC,iCAA4B,GAA5B,4BAA4B,CAAQ;QACpC,0BAAqB,GAArB,qBAAqB,CAAQ;QAE5B,uBAAkB,GAAlB,kBAAkB,CAKrB;QArBf;;;;WAIG;QACc,eAAU,GAA6C,IAAI,GAAG,EAAE,CAAC;IAiB/E,CAAC;IAEG,KAAK,CAAC,MAAoC;QAChD,oCAAoC;QACpC,sIAAsI;QACtI,OAAO,IAAI,OAAO,CACjB,MAAM,EACN,IAAI,CAAC,MAAM,EACX,IAAI,CAAC,2BAA2B,EAChC,IAAI,CAAC,4BAA4B,EACjC,IAAI,CAAC,qBAAqB,EAC1B,IAAI,CAAC,kBAAkB,CACvB,CAAC;IACH,CAAC;IAEM,eAAe,CAAC,MAAgC;QACtD,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC3C,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YAC1B,OAAO,MAAM,CAAC;QACf,CAAC;QACD,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,mBAAmB,EAAE,GAAG,EAAE,CACxE,IAAI,CAAC,aAAa,EAAE,CACpB,CAAC;QACF,OAAO,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IACnF,CAAC;IAEM,OAAO;QACb,iDAAiD;QACjD,IAAI,CAAC,aAAa,EAAE,CAAC;IACtB,CAAC;IAEO,aAAa;QACpB,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;QACxB,IAAI,IAAI,CAAC,wBAAwB,EAAE,CAAC;YACnC,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAChC,IAAI,CAAC,wBAAwB,GAAG,SAAS,CAAC;QAC3C,CAAC;IACF,CAAC;CACD;AAED;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,MAA8B,EAAE,MAAmB;IAC5E,OAAO,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,EAAE,CAAC;AACxD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,MAA8B,EAAE,MAAmB;IAC7E,MAAM,MAAM,GAAG,MAAM,CAAC,cAAc,EAAE,CAAC;IACvC,MAAM,OAAO,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;IACnC,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,kDAAkD,CAAC,CAAC;IAC1E,OAAO,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;AAClD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAC/B,MAA8B,EAC9B,MAAmB;IAEnB,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,MAAM,CAAC,CAAC,CAAC,IAAI,GAAG,EAAE,CAAC;IAC3B,CAAC;IACD,OAAO,IAAI,aAAa,CAAC,MAAM,CAAC,CAAC;AAClC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAC7B,MAA8B,EAC9B,MAAmB;IAEnB,kDAAkD;IAClD,gEAAgE;IAChE,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;IAClC,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;QACjC,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,OAAO,KAAK,CAAC;IACd,CAAC;IAED,OAAO,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,MAA6B;IACvD,MAAM,YAAY,GAAG,EAAE,GAAG,kBAAkB,EAAE,GAAG,MAAM,EAAE,CAAC;IAC1D,mDAAmD;IACnD,MAAM,CACL,YAAY,CAAC,2BAA2B,IAAI,CAAC,EAC7C,KAAK,CAAC,+CAA+C,CACrD,CAAC;IAEF,OAAO,YAAY,CAAC;AACrB,CAAC;AAED,MAAM,UAAU,gBAAgB,CAC/B,MAA8B,EAC9B,MAAwB;IAExB,MAAM,MAAM,GAA6C,IAAI,GAAG,EAAE,CAAC;IACnE,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;QACnD,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;IACxD,CAAC;IACD,OAAO,MAAM,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CACjC,MAA8B,EAC9B,MAAwB,EACxB,IAA8B,EAC9B,MAAgD;IAEhD,OAAO,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE;QACrC,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,gBAAgB,CAAC,CAAC;QACzE,IAAI,UAAU,YAAY,oBAAoB,EAAE,CAAC;YAChD,OAAO,IAAI,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;QACtC,CAAC;QACD,IAAI,UAAU,YAAY,sBAAsB,EAAE,CAAC;YAClD,MAAM,WAAW,GAAiB,EAAE,CAAC;YACrC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,UAAU,CAAC,gBAAgB,EAAE,CAAC;gBACxD,MAAM,UAAU,GAAG,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;gBAC/E,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;oBAC9B,OAAO,WAAW,CAAC;gBACpB,CAAC;gBACD,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC9B,CAAC;YACD,OAAO,IAAI,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC;QAChD,CAAC;QACD,OAAO,WAAW,CAAC;IACpB,CAAC,CAAC,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CACtC,MAA8B,EAC9B,MAAwB,EACxB,IAA2B,EAC3B,GAAa,EACb,MAAgD;IAEhD,MAAM,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,mBAAmB,CAAC,CAAC;IAC3E,IAAI,IAAI,CAAC,YAAY,KAAK,YAAY,CAAC,MAAM,EAAE,CAAC;QAC/C,OAAO,SAAS,CAAC;IAClB,CAAC;IACD,IAAI,IAAI,CAAC,KAAK,EAAE,IAAI,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO,SAAS,CAAC;IAClB,CAAC;IACD,MAAM,SAAS,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,EAAE,CAAC;IAC9C,MAAM,UAAU,GAAG,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;IACzE,IAAI,UAAU,YAAY,WAAW,EAAE,CAAC;QACvC,OAAO,SAAS,CAAC;IAClB,CAAC;IACD,OAAO,CAAC,GAAG,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC;AAC7B,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAgB;IAC9C,4FAA4F;IAC5F,8EAA8E;IAC9E,2BAA2B,EAAE,MAAM,CAAC,iBAAiB;IACrD,4BAA4B,EAAE,MAAM,CAAC,iBAAiB;IACtD,gGAAgG;IAChG,qBAAqB,EAAE,GAAG;IAC1B,+DAA+D;IAC/D,sCAAsC;IACtC,eAAe,EAAE,GAAG,EAAE,CAAC,WAAW;CAClC,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAgB;IAChD,2BAA2B,EAAE,MAAM,CAAC,iBAAiB;IACrD,4BAA4B,EAAE,MAAM,CAAC,iBAAiB;IACtD,qBAAqB,EAAE,CAAC;IACxB,eAAe,EAAE,GAAG,EAAE,CAAC,WAAW;CAClC,CAAC;AA8BF,SAAS,iBAAiB,CAAC,MAA8B,EAAE,MAAmB;IAC7E,OAAO,IAAI,UAAU,CACpB,MAAM,CAAC,IAAI,EACX,IAAI,GAAG,CAAC,eAAe,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,CAAC,WAAW,EAAE,EAAE,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,EAC1F,MAAM,CAAC,KAAK,CACZ,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CACzB,MAA8B,EAC9B,MAAmB,EACnB,MAAc,EACd,kBAA2B;IAE3B,MAAM,CAAC,MAAM,CAAC,IAAI,qCAA6B,EAAE,KAAK,CAAC,wBAAwB,CAAC,CAAC;IACjF,IAAI,MAAM,GAAgB,EAAE,CAAC;IAC7B,IAAI,SAAS,GAAG,MAAM,CAAC;IACvB,OAAO,SAAS,GAAG,CAAC,EAAE,CAAC;QACtB,MAAM,CAAC,MAAM,CAAC,IAAI,qCAA6B,EAAE,KAAK,CAAC,wBAAwB,CAAC,CAAC;QACjF,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC;QAChC,IAAI,WAAW,GAAG,KAAK,CAAC;QACxB,6CAA6C;QAC7C,gEAAgE;QAChE,IAAI,KAAK,KAAK,MAAM,CAAC,UAAU,EAAE,CAAC;YACjC,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;YACvC,IAAI,WAAW,IAAI,SAAS,EAAE,CAAC;gBAC9B,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;gBAClC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;oBACzB,IACC,KAAK,YAAY,aAAa;wBAC9B,KAAK,CAAC,SAAS,CAAC,MAAM,IAAI,MAAM,CAAC,4BAA4B,EAC5D,CAAC;wBACF,oDAAoD;wBACpD,yGAAyG;wBACzG,KAAK,MAAM,QAAQ,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;4BACxC,QAAQ,CAAC,cAAc,EAAE,CAAC;4BAC1B,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;wBACvB,CAAC;oBACF,CAAC;oBACD,KAAK,CAAC,cAAc,EAAE,CAAC;oBACvB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBACnB,SAAS,IAAI,WAAW,CAAC;oBACzB,WAAW,GAAG,IAAI,CAAC;oBACnB,IAAI,IAAI,GAAG,WAAW,CAAC;oBACvB,IAAI,kBAAkB,IAAI,SAAS,KAAK,CAAC,EAAE,CAAC;wBAC3C,IAAI,IAAI,CAAC,CAAC;oBACX,CAAC;oBACD,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;gBACxB,CAAC;YACF,CAAC;QACF,CAAC;QAED,IAAI,CAAC,WAAW,EAAE,CAAC;YAClB,MAAM,CAAC,MAAM,CAAC,IAAI,qCAA6B,EAAE,KAAK,CAAC,wBAAwB,CAAC,CAAC;YACjF,gEAAgE;YAChE,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;YACzB,MAAM,KAAK,GAAG,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAI,KAAK,YAAY,SAAS,EAAE,CAAC;gBAChC,MAAM,oBAAoB,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC;gBACpD,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAClC,oBAAoB,GAAG,MAAM,CAAC,qBAAqB,CACnD,CAAC;gBACF,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,iBAAiB,EAAE,SAAS,CAAC,CAAC;gBACzD,MAAM,QAAQ,GAAG,sBAAsB,CACtC,MAAM,EACN,KAAK,EACL,SAAS,EACT,SAAS,KAAK,SAAS,IAAI,kBAAkB,CAC7C,CAAC;gBACF,SAAS,IAAI,QAAQ,CAAC,cAAc,CAAC;gBACrC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACvB,CAAC;iBAAM,CAAC;gBACP,4CAA4C;gBAC5C,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;gBAC/C,SAAS,IAAI,CAAC,CAAC;gBACf,IAAI,CAAC,kBAAkB,IAAI,SAAS,KAAK,CAAC,EAAE,CAAC;oBAC5C,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACnB,CAAC;YACF,CAAC;QACF,CAAC;IACF,CAAC;IAED,8HAA8H;IAE9H,+DAA+D;IAC/D,OAAO,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,2BAA2B,EAAE,CAAC;QAC3D,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,2BAA2B,CAAC,CAAC;QACjF,MAAM,SAAS,GAAgB,EAAE,CAAC;QAClC,8DAA8D;QAC9D,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,GAAG,UAAU,CAAC,CAAC;QACzD,kEAAkE;QAClE,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,GAAG,UAAU,CAAC;QACzC,IAAI,WAAW,GAAG,CAAC,CAAC;QACpB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,UAAU,EAAE,KAAK,EAAE,EAAE,CAAC;YACjD,oEAAoE;YACpE,MAAM,GAAG,GAAG,WAAW,GAAG,SAAS,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC9D,SAAS,CAAC,IAAI,CAAC,IAAI,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;YAClE,WAAW,GAAG,GAAG,CAAC;QACnB,CAAC;QACD,MAAM,CAAC,WAAW,KAAK,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACjF,MAAM,GAAG,SAAS,CAAC;IACpB,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC;AAED,MAAM,UAAU,YAAY,CAC3B,MAA8B,EAC9B,KAAgB,EAChB,MAAe;IAEf,MAAM,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,+BAA+B,CAAC,CAAC;IAE1E,aAAa;IACb,oEAAoE;IAEpE,+DAA+D;IAC/D,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QACpB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;IACD,KAAK,MAAM,CAAC,GAAG,EAAE,UAAU,EAAE,MAAM,CAAC,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;QAC3D,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QACvB,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,KAAK,IAAI,OAAO,GAAG,MAAM,CAAC,SAAS,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC;YAC7E,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;YACzC,KAAK,EAAE,CAAC;QACT,CAAC;QACD,MAAM,CAAC,SAAS,EAAE,CAAC;QACnB,MAAM,CAAC,MAAM,KAAK,KAAK,EAAE,KAAK,CAAC,6BAA6B,CAAC,CAAC;IAC/D,CAAC;AACF,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,sBAAsB,CACrC,MAA8B,EAC9B,KAAgB,EAChB,iBAAyB,EACzB,kBAA2B;IAE3B,QAAQ;IACR,gGAAgG;IAEhG,MAAM,MAAM,GAAgB,EAAE,CAAC;IAC/B,IAAI,cAAc,GAAG,CAAC,CAAC;IACvB,OAAO,cAAc,IAAI,iBAAiB,EAAE,CAAC;QAC5C,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;QACpC,IAAI,cAAc,KAAK,iBAAiB,EAAE,CAAC;YAC1C,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBACzB,MAAM,CAAC,QAAQ,EAAE,CAAC;YACnB,CAAC;YACD,MAAM;QACP,CAAC;QACD,MAAM,CAAC,QAAQ,EAAE,CAAC;QAClB,IAAI,MAAM,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,EAAE,CAAC;YAChC,MAAM;QACP,CAAC;QACD,cAAc,IAAI,CAAC,CAAC;IACrB,CAAC;IACD,OAAO,IAAI,YAAY,CAAC,KAAK,CAAC,kBAAkB,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC,CAAC;AAC3E,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert, oob } from \"@fluidframework/core-utils/internal\";\n\nimport {\n\tCursorLocationType,\n\ttype FieldKey,\n\ttype ITreeCursorSynchronous,\n\tLeafNodeStoredSchema,\n\tObjectNodeStoredSchema,\n\ttype StoredSchemaCollection,\n\ttype TreeFieldStoredSchema,\n\ttype TreeNodeSchemaIdentifier,\n\ttype TreeStoredSchema,\n\ttype TreeStoredSchemaSubscription,\n\ttype TreeValue,\n\ttype Value,\n\tmapCursorFields,\n\tMultiplicity,\n} from \"../../core/index.js\";\nimport { fail, getOrCreate } from \"../../util/index.js\";\nimport type { FullSchemaPolicy } from \"../modular-schema/index.js\";\n\nimport { BasicChunk } from \"./basicChunk.js\";\nimport { type TreeChunk, tryGetChunk } from \"./chunk.js\";\nimport { SequenceChunk } from \"./sequenceChunk.js\";\nimport { type FieldShape, TreeShape, UniformChunk } from \"./uniformChunk.js\";\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] ?? oob();\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(\n\tcursor: ITreeCursorSynchronous,\n\tpolicy: ChunkPolicy,\n): TreeChunk {\n\tconst chunks = chunkField(cursor, policy);\n\tif (chunks.length === 1) {\n\t\treturn chunks[0] ?? oob();\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(\n\tcursor: ITreeCursorSynchronous,\n\tpolicy: ChunkPolicy,\n): 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) ?? 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] ?? oob();\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"]}
+{"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, oob } from \"@fluidframework/core-utils/internal\";\n\nimport {\n\tCursorLocationType,\n\ttype FieldKey,\n\ttype ITreeCursorSynchronous,\n\tLeafNodeStoredSchema,\n\tObjectNodeStoredSchema,\n\ttype StoredSchemaCollection,\n\ttype TreeFieldStoredSchema,\n\ttype TreeNodeSchemaIdentifier,\n\ttype TreeStoredSchema,\n\ttype TreeStoredSchemaSubscription,\n\ttype TreeValue,\n\ttype Value,\n\tmapCursorFields,\n\tMultiplicity,\n\tValueSchema,\n} from \"../../core/index.js\";\nimport { fail, getOrCreate } from \"../../util/index.js\";\nimport type { FullSchemaPolicy } from \"../modular-schema/index.js\";\n\nimport { BasicChunk } from \"./basicChunk.js\";\nimport { type TreeChunk, tryGetChunk } from \"./chunk.js\";\nimport { SequenceChunk } from \"./sequenceChunk.js\";\nimport { type FieldShape, TreeShape, UniformChunk } from \"./uniformChunk.js\";\nimport { isStableNodeKey } from \"../node-key/index.js\";\nimport type { IIdCompressor } from \"@fluidframework/id-compressor\";\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: ChunkCompressor): TreeChunk {\n\treturn chunkRange(cursor, policy, 1, true)[0] ?? oob();\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(\n\tcursor: ITreeCursorSynchronous,\n\tpolicy: ChunkCompressor,\n): 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(\n\tcursor: ITreeCursorSynchronous,\n\tpolicy: ChunkCompressor,\n): TreeChunk {\n\tconst chunks = chunkField(cursor, policy);\n\tif (chunks.length === 1) {\n\t\treturn chunks[0] ?? oob();\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(\n\tcursor: ITreeCursorSynchronous,\n\tpolicy: ChunkCompressor,\n): 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\t// Allow all string values (but only string values) to be compressed by the id compressor.\n\t\t\t// This allows compressing all compressible identifiers without requiring additional context to know which values could be identifiers.\n\t\t\t// Attempting to compress other string shouldn't have significant overhead,\n\t\t\t// and if any of them do end up compressing, that's a benefit not a bug.\n\t\t\treturn treeSchema.leafValue === ValueSchema.String\n\t\t\t\t? new TreeShape(type, true, [], true)\n\t\t\t\t: new TreeShape(type, true, [], false);\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) ?? 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] ?? oob();\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\nexport interface ChunkCompressor {\n\treadonly policy: ChunkPolicy;\n\t/**\n\t * If the idCompressor is provided, {@link UniformChunk}s with identifiers will be encoded for its in-memory representation.\n\t * @remarks\n\t * This compression applies to {@link UniformChunk}s when {@link TreeShape.maybeDecompressedStringAsNumber} is set.\n\t * If the `policy` does not use UniformChunks or does not set `maybeDecompressedStringAsNumber`, then no compression will be applied even when providing `idCompressor`.\n\t */\n\treadonly idCompressor: IIdCompressor | undefined;\n}\n\nfunction newBasicChunkTree(\n\tcursor: ITreeCursorSynchronous,\n\tpolicy: ChunkCompressor,\n): 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\tchunkCompressor: ChunkCompressor,\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 <= chunkCompressor.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 = chunkCompressor.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 / chunkCompressor.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\tchunkCompressor.idCompressor,\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, chunkCompressor));\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 > chunkCompressor.policy.sequenceChunkSplitThreshold) {\n\t\tconst chunkCount = Math.ceil(\n\t\t\toutput.length / chunkCompressor.policy.sequenceChunkSplitThreshold,\n\t\t);\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/**\n * @param idCompressor - compressor used to encoded string values that are compressible by the idCompressor for in-memory representation.\n * If the idCompressor is not provided, the values will be the original uncompressed values.\n */\nexport function insertValues(\n\tcursor: ITreeCursorSynchronous,\n\tshape: TreeShape,\n\tvalues: Value[],\n\tidCompressor?: IIdCompressor,\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\tif (\n\t\t\ttypeof cursor.value === \"string\" &&\n\t\t\tidCompressor !== undefined &&\n\t\t\tisStableNodeKey(cursor.value)\n\t\t) {\n\t\t\tvalues.push(idCompressor.tryRecompress(cursor.value) ?? cursor.value);\n\t\t} else {\n\t\t\tvalues.push(cursor.value);\n\t\t}\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, idCompressor);\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 *\n * @param idCompressor - compressor used to encoded string values that are compressible by the idCompressor for in-memory representation.\n * If the idCompressor is not provided, the values will be the original uncompressed values.\n */\nexport function uniformChunkFromCursor(\n\tcursor: ITreeCursorSynchronous,\n\tshape: TreeShape,\n\tmaxTopLevelLength: number,\n\tskipLastNavigation: boolean,\n\tidCompressor?: IIdCompressor,\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, idCompressor);\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, idCompressor);\n}\n"]}

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

@@ -6,6 +6,7 @@ import { type Anchor, AnchorSet, type DeltaVisitor, type DetachedField, type Fie
 import { BasicChunk, BasicChunkCursor, type SiblingsOrKey } from "./basicChunk.js";
 import type { ChunkedCursor, TreeChunk } from "./chunk.js";
 import { type IChunker } from "./chunkTree.js";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 /**
  * Implementation of IEditableForest based on copy on write chunks.
  *
@@ -16,6 +17,7 @@ export declare class ChunkedForest implements IEditableForest {
     readonly schema: TreeStoredSchemaSubscription;
     readonly chunker: IChunker;
     readonly anchors: AnchorSet;
+    readonly idCompressor?: IIdCompressor | undefined;
     private activeVisitor?;
     private readonly events;
     /**
@@ -24,7 +26,7 @@ export declare class ChunkedForest implements IEditableForest {
      * @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);
+    constructor(roots: BasicChunk, schema: TreeStoredSchemaSubscription, chunker: IChunker, anchors?: AnchorSet, idCompressor?: IIdCompressor | undefined);
     get isEmpty(): boolean;
     on<K extends keyof ForestEvents>(eventName: K, listener: ForestEvents[K]): () => void;
     clone(schema: TreeStoredSchemaSubscription, anchors: AnchorSet): ChunkedForest;
@@ -52,6 +54,6 @@ declare class Cursor extends BasicChunkCursor implements ITreeSubscriptionCursor
 /**
  * @returns an implementation of {@link IEditableForest} with no data or schema.
  */
-export declare function buildChunkedForest(chunker: IChunker, anchors?: AnchorSet): ChunkedForest;
+export declare function buildChunkedForest(chunker: IChunker, anchors?: AnchorSet, idCompressor?: IIdCompressor): ChunkedForest;
 export {};
 //# sourceMappingURL=chunkedForest.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"chunkedForest.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/chunked-forest/chunkedForest.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EACN,KAAK,MAAM,EACX,SAAS,EACT,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC5B,4BAA4B,EAI5B,oBAAoB,EACpB,KAAK,4BAA4B,EACjC,KAAK,MAAM,EAKX,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACnF,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC3D,OAAO,EAAE,KAAK,QAAQ,EAA6B,MAAM,gBAAgB,CAAC;AAW1E;;;;GAIG;AACH,qBAAa,aAAc,YAAW,eAAe;IAY5C,KAAK,EAAE,UAAU;aACR,MAAM,EAAE,4BAA4B;aACpC,OAAO,EAAE,QAAQ;aACjB,OAAO,EAAE,SAAS;IAdnC,OAAO,CAAC,aAAa,CAAC,CAAe;IAErC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IAExD;;;;;OAKG;gBAEK,KAAK,EAAE,UAAU,EACR,MAAM,EAAE,4BAA4B,EACpC,OAAO,EAAE,QAAQ,EACjB,OAAO,GAAE,SAA2B;IAGrD,IAAW,OAAO,IAAI,OAAO,CAE5B;IAEM,EAAE,CAAC,CAAC,SAAS,MAAM,YAAY,EACrC,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,GACvB,MAAM,IAAI;IAIN,KAAK,CAAC,MAAM,EAAE,4BAA4B,EAAE,OAAO,EAAE,SAAS,GAAG,aAAa;IAK9E,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAIlC,cAAc,IAAI,YAAY;IA0KrC,OAAO,CAAC,2BAA2B,CAAK;IACjC,gBAAgB,IAAI,aAAa;IAUjC,cAAc,IAAI,MAAM;IAiBxB,mBAAmB,CACzB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,uBAAuB,GACnC,oBAAoB;IAShB,oBAAoB,CAC1B,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,uBAAuB,GACnC,oBAAoB;IAkBhB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,uBAAuB,GAAG,IAAI;IAmClF,4BAA4B,IAAI,sBAAsB;CAK7D;AAED,cAAM,MAAO,SAAQ,gBAAiB,YAAW,uBAAuB;aAEtD,MAAM,EAAE,aAAa;IAC9B,KAAK,EAAE,4BAA4B;gBAD1B,MAAM,EAAE,aAAa,EAC9B,KAAK,EAAE,4BAA4B,EAC1C,IAAI,EAAE,SAAS,SAAS,EAAE,EAC1B,YAAY,EAAE,aAAa,EAAE,EAC7B,UAAU,EAAE,MAAM,EAAE,EACpB,iBAAiB,EAAE,MAAM,EAAE,EAC3B,qBAAqB,EAAE,MAAM,EAAE,EAC/B,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,YAAY,EAAE,aAAa,GAAG,SAAS;IAgBjC,qBAAqB,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI;IAajC,IAAI,IAAI,MAAM;IAmBvB,gBAAgB,IAAI,WAAW;IAO/B,IAAI,IAAI,IAAI;IAIZ,WAAW,IAAI,MAAM;IAIrB,KAAK,IAAI,IAAI;CAIpB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,aAAa,CAExF"}
+{"version":3,"file":"chunkedForest.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/chunked-forest/chunkedForest.ts"],"names":[],"mappings":"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"}

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

@@ -23,11 +23,12 @@ export class ChunkedForest {
      * @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, schema, chunker, anchors = new AnchorSet()) {
+    constructor(roots, schema, chunker, anchors = new AnchorSet(), idCompressor) {
         this.roots = roots;
         this.schema = schema;
         this.chunker = chunker;
         this.anchors = anchors;
+        this.idCompressor = idCompressor;
         this.events = createEmitter();
         this.nextDetachedFieldIdentifier = 0;
     }
@@ -71,7 +72,10 @@ export class ChunkedForest {
             },
             create(content, destination) {
                 this.forest.events.emit("beforeChange");
-                const chunks = content.map((c) => chunkTree(c, this.forest.chunker));
+                const chunks = content.map((c) => chunkTree(c, {
+                    policy: this.forest.chunker,
+                    idCompressor: this.forest.idCompressor,
+                }));
                 this.forest.roots.fields.set(destination, chunks);
                 this.forest.events.emit("afterRootFieldCreated", destination);
             },
@@ -156,7 +160,10 @@ export class ChunkedForest {
                     // 2. Support traversing sequence chunks.
                     //
                     // Maybe build path when visitor navigates then lazily sync to chunk tree when editing?
-                    const newChunks = mapCursorField(found.cursor(), (cursor) => basicChunkTree(cursor, this.forest.chunker));
+                    const newChunks = mapCursorField(found.cursor(), (cursor) => basicChunkTree(cursor, {
+                        policy: this.forest.chunker,
+                        idCompressor: this.forest.idCompressor,
+                    }));
                     // TODO: this could fail for really long chunks being split (due to argument count limits).
                     // Current implementations of chunks shouldn't ever be that long, but it could be an issue if they get bigger.
                     chunks.splice(indexOfChunk, 1, ...newChunks);
@@ -294,7 +301,7 @@ class Cursor extends BasicChunkCursor {
 /**
  * @returns an implementation of {@link IEditableForest} with no data or schema.
  */
-export function buildChunkedForest(chunker, anchors) {
-    return new ChunkedForest(makeRoot(), chunker.schema, chunker, anchors);
+export function buildChunkedForest(chunker, anchors, idCompressor) {
+    return new ChunkedForest(makeRoot(), chunker.schema, chunker, anchors, idCompressor);
 }
 //# sourceMappingURL=chunkedForest.js.map