@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/dist/feature-libraries/chunked-forest/codec/chunkEncodingGeneric.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkEncodingGeneric.js","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/chunkEncodingGeneric.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 { TreeValue } from \"../../../core\";\nimport { fail } from \"../../../util\";\nimport { FluidSerializableReadOnly } from \"../../valueUtilities\";\nimport { EncodedFieldBatchGeneric } from \"./formatGeneric\";\nimport {\n\tCounter,\n\tCounterFilter,\n\tDeduplicationTable,\n\tjsonMinimizingFilter,\n} from \"./chunkCodecUtilities\";\n\n/**\n * An identifier which can be compressed using {@link Counter}.\n *\n * @remarks\n * Compression of Identifiers is done after the output is otherwise generated to enable counting all the usages.\n * To avoid having to decode the decode the data array to determine which data is an identifier and which is some other string,\n * some recognizable representation is required.\n * Using a class and checking its prototype works for this, and is why IdentifierToken is a class.\n */\nexport class IdentifierToken {\n\tpublic constructor(public readonly identifier: string) {}\n}\n\n/**\n * Format for data emitted during encoding, before dictionary compression of identifiers.\n *\n * @remarks\n * These buffers are mutated after construction if they contain identifiers or shapes.\n */\nexport type BufferFormat<TEncodedShape> = (\n\t| FluidSerializableReadOnly\n\t| Shape<TEncodedShape>\n\t| IdentifierToken\n\t| BufferFormat<TEncodedShape>\n)[];\n\n/**\n * Replace shapes and identifiers in buffer and any nested arrays.\n *\n * This looks inside nested arrays (including transitively) but not inside objects.\n *\n * Note that this modifies `buffer` to avoid having to copy it.\n */\nexport function handleShapesAndIdentifiers<TEncodedShape>(\n\tversion: number,\n\tbuffer: BufferFormat<TEncodedShape>[],\n\tidentifierFilter: CounterFilter<string> = jsonMinimizingFilter,\n): EncodedFieldBatchGeneric<TEncodedShape> {\n\tconst identifiers = new Counter<string>();\n\tconst shapes = new Counter<Shape<TEncodedShape>>();\n\t// Shapes can reference other shapes (and identifiers), so we need to traverse the shape graph.\n\t// These collections enable that.\n\tconst shapesSeen = new Set<Shape<TEncodedShape>>();\n\tconst shapeToCount: Shape<TEncodedShape>[] = [];\n\tconst shapeDiscovered = (shape: Shape<TEncodedShape>) => {\n\t\tshapes.add(shape);\n\t\tif (!shapesSeen.has(shape)) {\n\t\t\tshapesSeen.add(shape);\n\t\t\tshapeToCount.push(shape);\n\t\t}\n\t};\n\n\tconst arrays: BufferFormat<TEncodedShape>[] = [buffer];\n\tfor (const array of arrays) {\n\t\tfor (const item of array) {\n\t\t\tif (item instanceof IdentifierToken) {\n\t\t\t\tidentifiers.add(item.identifier);\n\t\t\t} else if (item instanceof Shape) {\n\t\t\t\tshapeDiscovered(item);\n\t\t\t} else if (Array.isArray(item)) {\n\t\t\t\t// In JS it is legal to push items to an array which is being iterated,\n\t\t\t\t// and they will be visited in order.\n\t\t\t\tarrays.push(item);\n\t\t\t} else if (\n\t\t\t\titem !== null &&\n\t\t\t\ttypeof item === \"object\" &&\n\t\t\t\t(item as any).shape instanceof Shape\n\t\t\t) {\n\t\t\t\t// because \"serializable\" is allowed in buffer and it has type `any`, its very easy to mess up including of shapes in the buffer.\n\t\t\t\t// This catches the easiest way to get it wrong.\n\t\t\t\tfail(\"encoder interface instead of shape written to stream\");\n\t\t\t}\n\t\t}\n\t}\n\n\t// Traverse shape graph, discovering and counting all shape to shape and shape to identifier references.\n\t{\n\t\tlet item: Shape<TEncodedShape> | undefined;\n\t\twhile ((item = shapeToCount.pop()) !== undefined) {\n\t\t\titem.count(identifiers, shapeDiscovered);\n\t\t}\n\t}\n\n\t// Determine substitutions for identifiers and shapes:\n\tconst identifierTable = identifiers.buildTable(identifierFilter);\n\tconst shapeTable = shapes.buildTable();\n\n\tfor (const array of arrays) {\n\t\tfor (let index = 0; index < array.length; index++) {\n\t\t\tconst item = array[index];\n\t\t\tif (item instanceof IdentifierToken) {\n\t\t\t\tarray[index] = identifierTable.valueToIndex.get(item.identifier) ?? item.identifier;\n\t\t\t} else if (item instanceof Shape) {\n\t\t\t\tarray[index] = shapeTable.valueToIndex.get(item) ?? fail(\"missing shape\");\n\t\t\t}\n\t\t}\n\t}\n\n\tconst encodedShapes = shapeTable.indexToValue.map((shape) =>\n\t\tshape.encodeShape(identifierTable, shapeTable),\n\t);\n\n\treturn {\n\t\tversion,\n\t\t// TODO: fix readonly typing issues to remove this cast.\n\t\tidentifiers: identifierTable.indexToValue as string[],\n\t\tshapes: encodedShapes,\n\t\tdata: buffer as TreeValue[][],\n\t};\n}\n\n/**\n * A tree shape.\n * This similar to a schema for a tree, though it may be more or less specific than the actual schema system used.\n * Can be encoded into a `TEncodedShape`: when doing so encodes references to shapes (if needed) using {@link Counter}:\n * this can include recursive references (direct or indirect).\n *\n * @remarks\n * Deduplication of shapes is done after the output is otherwise generated (including identifier dictionary encoding).\n * To avoid having to decode the data array to determine which data is a shape and which is some other object,\n * some recognizable representation is required.\n * Using a class and checking its prototype works for this, and is why Shape is a class.\n *\n * Note that deduplication compares shapes by object identity not by content, so encoders must ensure shapes are not duplicated to achieve efficient encoding.\n * Comparison by content would be difficult due to shape containing references to other shapes.\n *\n * @privateRemarks\n * Unlike with identifiers, conversion from the initial form (this class / IdentifierToken) is done by the `encodeShape` method, not by general purpose logic in `handleShapesAndIdentifiers`.\n * For `handleShapesAndIdentifiers` to do the conversion without help from `encodeShape`,\n * instances of this Shape class would have to either be or output an object that is identical to the `TEncodedShape` format except with all shape references as object references instead of indexes.\n * Those objects would have to be deeply traversed looking for shape objects to replace with reference indexes.\n * This is possible, but making it type safe would involve generating derived types from the `TEncodedShape` deeply replacing any shape references, as well as requiring deep traversal of all objects in the encoded output.\n * Such an approach seemed less maintainable and readable than the design taken here which avoids the need for those derived types.\n */\nexport abstract class Shape<TEncodedShape> {\n\t/**\n\t * Count this shape's contents.\n\t *\n\t * Used to discover referenced shapes (to ensure they are included in the `shapes` passed to `encodeShape`),\n\t * as well as count usages of shapes and identifiers for more efficient dictionary encoding. See {@link Counter}.\n\t *\n\t * @param shapes - must be invoked with each directly referenced shape (which must provided to `encodeShape`).\n\t * Can be invoked multiple times if a shape is referenced more than once for more efficient dictionary encoding.\n\t * Should not be invoked with `this` unless this shape references itself.\n\t */\n\tpublic abstract count(\n\t\tidentifiers: Counter<string>,\n\t\tshapes: (shape: Shape<TEncodedShape>) => void,\n\t): void;\n\n\t/**\n\t * Produce the final encoded format for this shape.\n\t *\n\t * @param identifiers - a subset of identifiers used in this tree, and their corresponding indexes to use for the dictionary encoding.\n\t * Can be used to encode identifiers referenced by this shape.\n\t * @param shapes - includes a superset of shapes reported by count.\n\t * Used to encode references to shapes as numbers.\n\t */\n\tpublic abstract encodeShape(\n\t\tidentifiers: DeduplicationTable<string>,\n\t\tshapes: DeduplicationTable<Shape<TEncodedShape>>,\n\t): TEncodedShape;\n}\n"]}

package/dist/feature-libraries/chunked-forest/codec/codecs.d.ts

@@ -0,0 +1,32 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { ITreeCursorSynchronous, StoredSchemaCollection } from "../../../core";
+import { JsonCompatibleReadOnly } from "../../../util";
+import { ICodecOptions, IJsonCodec } from "../../../codec";
+import { FullSchemaPolicy } from "../../modular-schema";
+import { IJsonCodecWithContext } from "../../../codec/codec";
+import { TreeCompressionStrategy } from "../../treeCompressionUtils";
+import { EncodedFieldBatch } from "./format";
+import { FieldBatch } from "./fieldBatch";
+/**
+ * Helper for processing multiple fields one at a time.
+ */
+export declare class FieldBatchEncoder {
+    private readonly fields;
+    add(field: ITreeCursorSynchronous): number;
+    encode(codec: IJsonCodec<FieldBatch, EncodedFieldBatch>): EncodedFieldBatch;
+}
+export interface Context {
+    readonly encodeType: TreeCompressionStrategy;
+    readonly schema?: SchemaAndPolicy;
+}
+export type FieldBatchCodec = IJsonCodecWithContext<FieldBatch, EncodedFieldBatch, JsonCompatibleReadOnly, Context>;
+export declare function makeFieldBatchCodec(options: ICodecOptions): IJsonCodecWithContext<FieldBatch, EncodedFieldBatch, JsonCompatibleReadOnly, Context>;
+interface SchemaAndPolicy {
+    readonly schema: StoredSchemaCollection;
+    readonly policy: FullSchemaPolicy;
+}
+export {};
+//# sourceMappingURL=codecs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codecs.d.ts","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/codecs.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAsB,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACnG,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAErE,OAAO,EAAE,iBAAiB,EAAiB,MAAM,UAAU,CAAC;AAG5D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C;;GAEG;AACH,qBAAa,iBAAiB;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IAChD,GAAG,CAAC,KAAK,EAAE,sBAAsB,GAAG,MAAM;IAQ1C,MAAM,CAAC,KAAK,EAAE,UAAU,CAAC,UAAU,EAAE,iBAAiB,CAAC,GAAG,iBAAiB;CAGlF;AAED,MAAM,WAAW,OAAO;IACvB,QAAQ,CAAC,UAAU,EAAE,uBAAuB,CAAC;IAC7C,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;CAClC;AAED,MAAM,MAAM,eAAe,GAAG,qBAAqB,CAClD,UAAU,EACV,iBAAiB,EACjB,sBAAsB,EACtB,OAAO,CACP,CAAC;AAEF,wBAAgB,mBAAmB,CAClC,OAAO,EAAE,aAAa,GACpB,qBAAqB,CAAC,UAAU,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,OAAO,CAAC,CA2CvF;AAED,UAAU,eAAe;IACxB,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;CAClC"}

package/dist/feature-libraries/chunked-forest/codec/codecs.js

@@ -0,0 +1,68 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFieldBatchCodec = exports.FieldBatchEncoder = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const treeCompressionUtils_1 = require("../../treeCompressionUtils");
+const versioned_1 = require("../../versioned");
+const format_1 = require("./format");
+const chunkDecoding_1 = require("./chunkDecoding");
+const schemaBasedEncoding_1 = require("./schemaBasedEncoding");
+const uncompressedEncode_1 = require("./uncompressedEncode");
+/**
+ * Helper for processing multiple fields one at a time.
+ */
+class FieldBatchEncoder {
+    constructor() {
+        this.fields = [];
+    }
+    add(field) {
+        (0, core_utils_1.assert)(field.mode === 1 /* CursorLocationType.Fields */, "Cursor for batch must be in fields mode.");
+        this.fields.push(field);
+        return this.fields.length - 1;
+    }
+    encode(codec) {
+        return codec.encode(this.fields);
+    }
+}
+exports.FieldBatchEncoder = FieldBatchEncoder;
+function makeFieldBatchCodec(options) {
+    // TODO: every time context changes, withSchemaValidation and makeVersionedCodec recompile their json validators.
+    // Those should be reused. Making more code context aware could fix that.
+    return (context) => (0, versioned_1.makeVersionedValidatedCodec)(options, format_1.validVersions, format_1.EncodedFieldBatch, {
+        encode: (data) => {
+            for (const cursor of data) {
+                (0, core_utils_1.assert)(cursor.mode === 1 /* CursorLocationType.Fields */, "FieldBatch expects fields cursors");
+            }
+            let encoded;
+            switch (context.encodeType) {
+                case treeCompressionUtils_1.TreeCompressionStrategy.Uncompressed:
+                    encoded = (0, uncompressedEncode_1.uncompressedEncode)(data);
+                    break;
+                case treeCompressionUtils_1.TreeCompressionStrategy.Compressed:
+                    // eslint-disable-next-line unicorn/prefer-ternary
+                    if (context.schema !== undefined) {
+                        encoded = (0, schemaBasedEncoding_1.schemaCompressedEncode)(context.schema.schema, context.schema.policy, data);
+                    }
+                    else {
+                        // TODO: consider enabling a somewhat compressed but not schema accelerated encode.
+                        encoded = (0, uncompressedEncode_1.uncompressedEncode)(data);
+                    }
+                    break;
+                default:
+                    (0, core_utils_1.unreachableCase)(context.encodeType);
+            }
+            // TODO: consider checking input data was in schema.
+            return encoded;
+        },
+        decode: (data) => {
+            // TODO: consider checking data is in schema.
+            return (0, chunkDecoding_1.decode)(data).map((chunk) => chunk.cursor());
+        },
+    });
+}
+exports.makeFieldBatchCodec = makeFieldBatchCodec;
+//# sourceMappingURL=codecs.js.map

package/dist/feature-libraries/chunked-forest/codec/codecs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs.js","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/codecs.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,2DAAqE;AAOrE,qEAAqE;AACrE,+CAA8D;AAC9D,qCAA4D;AAC5D,mDAAyC;AACzC,+DAA+D;AAE/D,6DAA0D;AAE1D;;GAEG;AACH,MAAa,iBAAiB;IAA9B;QACkB,WAAM,GAA6B,EAAE,CAAC;IAYxD,CAAC;IAXO,GAAG,CAAC,KAA6B;QACvC,IAAA,mBAAM,EACL,KAAK,CAAC,IAAI,sCAA8B,EACxC,0CAA0C,CAC1C,CAAC;QACF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxB,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;IAC/B,CAAC;IACM,MAAM,CAAC,KAAgD;QAC7D,OAAO,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAClC,CAAC;CACD;AAbD,8CAaC;AAcD,SAAgB,mBAAmB,CAClC,OAAsB;IAEtB,iHAAiH;IACjH,yEAAyE;IACzE,OAAO,CAAC,OAAgB,EAAE,EAAE,CAC3B,IAAA,uCAA2B,EAAC,OAAO,EAAE,sBAAa,EAAE,0BAAiB,EAAE;QACtE,MAAM,EAAE,CAAC,IAAgB,EAAqB,EAAE;YAC/C,KAAK,MAAM,MAAM,IAAI,IAAI,EAAE;gBAC1B,IAAA,mBAAM,EACL,MAAM,CAAC,IAAI,sCAA8B,EACzC,mCAAmC,CACnC,CAAC;aACF;YACD,IAAI,OAA0B,CAAC;YAC/B,QAAQ,OAAO,CAAC,UAAU,EAAE;gBAC3B,KAAK,8CAAuB,CAAC,YAAY;oBACxC,OAAO,GAAG,IAAA,uCAAkB,EAAC,IAAI,CAAC,CAAC;oBACnC,MAAM;gBACP,KAAK,8CAAuB,CAAC,UAAU;oBACtC,kDAAkD;oBAClD,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE;wBACjC,OAAO,GAAG,IAAA,4CAAsB,EAC/B,OAAO,CAAC,MAAM,CAAC,MAAM,EACrB,OAAO,CAAC,MAAM,CAAC,MAAM,EACrB,IAAI,CACJ,CAAC;qBACF;yBAAM;wBACN,mFAAmF;wBACnF,OAAO,GAAG,IAAA,uCAAkB,EAAC,IAAI,CAAC,CAAC;qBACnC;oBAED,MAAM;gBACP;oBACC,IAAA,4BAAe,EAAC,OAAO,CAAC,UAAU,CAAC,CAAC;aACrC;YAED,oDAAoD;YACpD,OAAO,OAAO,CAAC;QAChB,CAAC;QACD,MAAM,EAAE,CAAC,IAAuB,EAAc,EAAE;YAC/C,6CAA6C;YAC7C,OAAO,IAAA,sBAAM,EAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;QACpD,CAAC;KACD,CAAC,CAAC;AACL,CAAC;AA7CD,kDA6CC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert, unreachableCase } from \"@fluidframework/core-utils\";\nimport { CursorLocationType, ITreeCursorSynchronous, StoredSchemaCollection } from \"../../../core\";\nimport { JsonCompatibleReadOnly } from \"../../../util\";\nimport { ICodecOptions, IJsonCodec } from \"../../../codec\";\nimport { FullSchemaPolicy } from \"../../modular-schema\";\n// eslint-disable-next-line import/no-internal-modules\nimport { IJsonCodecWithContext } from \"../../../codec/codec\";\nimport { TreeCompressionStrategy } from \"../../treeCompressionUtils\";\nimport { makeVersionedValidatedCodec } from \"../../versioned\";\nimport { EncodedFieldBatch, validVersions } from \"./format\";\nimport { decode } from \"./chunkDecoding\";\nimport { schemaCompressedEncode } from \"./schemaBasedEncoding\";\nimport { FieldBatch } from \"./fieldBatch\";\nimport { uncompressedEncode } from \"./uncompressedEncode\";\n\n/**\n * Helper for processing multiple fields one at a time.\n */\nexport class FieldBatchEncoder {\n\tprivate readonly fields: ITreeCursorSynchronous[] = [];\n\tpublic add(field: ITreeCursorSynchronous): number {\n\t\tassert(\n\t\t\tfield.mode === CursorLocationType.Fields,\n\t\t\t\"Cursor for batch must be in fields mode.\",\n\t\t);\n\t\tthis.fields.push(field);\n\t\treturn this.fields.length - 1;\n\t}\n\tpublic encode(codec: IJsonCodec<FieldBatch, EncodedFieldBatch>): EncodedFieldBatch {\n\t\treturn codec.encode(this.fields);\n\t}\n}\n\nexport interface Context {\n\treadonly encodeType: TreeCompressionStrategy;\n\treadonly schema?: SchemaAndPolicy;\n}\n\nexport type FieldBatchCodec = IJsonCodecWithContext<\n\tFieldBatch,\n\tEncodedFieldBatch,\n\tJsonCompatibleReadOnly,\n\tContext\n>;\n\nexport function makeFieldBatchCodec(\n\toptions: ICodecOptions,\n): IJsonCodecWithContext<FieldBatch, EncodedFieldBatch, JsonCompatibleReadOnly, Context> {\n\t// TODO: every time context changes, withSchemaValidation and makeVersionedCodec recompile their json validators.\n\t// Those should be reused. Making more code context aware could fix that.\n\treturn (context: Context) =>\n\t\tmakeVersionedValidatedCodec(options, validVersions, EncodedFieldBatch, {\n\t\t\tencode: (data: FieldBatch): EncodedFieldBatch => {\n\t\t\t\tfor (const cursor of data) {\n\t\t\t\t\tassert(\n\t\t\t\t\t\tcursor.mode === CursorLocationType.Fields,\n\t\t\t\t\t\t\"FieldBatch expects fields cursors\",\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\tlet encoded: EncodedFieldBatch;\n\t\t\t\tswitch (context.encodeType) {\n\t\t\t\t\tcase TreeCompressionStrategy.Uncompressed:\n\t\t\t\t\t\tencoded = uncompressedEncode(data);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase TreeCompressionStrategy.Compressed:\n\t\t\t\t\t\t// eslint-disable-next-line unicorn/prefer-ternary\n\t\t\t\t\t\tif (context.schema !== undefined) {\n\t\t\t\t\t\t\tencoded = schemaCompressedEncode(\n\t\t\t\t\t\t\t\tcontext.schema.schema,\n\t\t\t\t\t\t\t\tcontext.schema.policy,\n\t\t\t\t\t\t\t\tdata,\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// TODO: consider enabling a somewhat compressed but not schema accelerated encode.\n\t\t\t\t\t\t\tencoded = uncompressedEncode(data);\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tunreachableCase(context.encodeType);\n\t\t\t\t}\n\n\t\t\t\t// TODO: consider checking input data was in schema.\n\t\t\t\treturn encoded;\n\t\t\t},\n\t\t\tdecode: (data: EncodedFieldBatch): FieldBatch => {\n\t\t\t\t// TODO: consider checking data is in schema.\n\t\t\t\treturn decode(data).map((chunk) => chunk.cursor());\n\t\t\t},\n\t\t});\n}\n\ninterface SchemaAndPolicy {\n\treadonly schema: StoredSchemaCollection;\n\treadonly policy: FullSchemaPolicy;\n}\n"]}

package/dist/feature-libraries/chunked-forest/codec/compressedEncode.d.ts

@@ -0,0 +1,149 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { FieldKey, TreeFieldStoredSchema, ITreeCursorSynchronous, TreeNodeSchemaIdentifier, Value, FieldKindIdentifier } from "../../../core";
+import { type FieldKind } from "../../modular-schema";
+import { BufferFormat as BufferFormatGeneric, Shape as ShapeGeneric } from "./chunkEncodingGeneric";
+import { Counter, DeduplicationTable } from "./chunkCodecUtilities";
+import { EncodedChunkShape, EncodedValueShape, EncodedFieldBatch } from "./format";
+import { FieldBatch } from "./fieldBatch";
+/**
+ * Encode data from `FieldBatch` in into an `EncodedChunk`.
+ *
+ * Optimized for encoded size and encoding performance.
+ *
+ * Most of the compression strategy comes from the policy provided via `cache`.
+ */
+export declare function compressedEncode(fieldBatch: FieldBatch, cache: EncoderCache): EncodedFieldBatch;
+export type BufferFormat = BufferFormatGeneric<EncodedChunkShape>;
+export type Shape = ShapeGeneric<EncodedChunkShape>;
+/**
+ * Like {@link FieldEncoder}, except data will be prefixed with the key.
+ */
+export interface KeyedFieldEncoder {
+    readonly key: FieldKey;
+    readonly shape: FieldEncoder;
+}
+/**
+ * An encoder with an associated shape.
+ */
+export interface Encoder {
+    /**
+     * The shape which describes how the encoded data is laid out.
+     * Used by decoders to interpret the output of `encodeNode`.
+     */
+    readonly shape: Shape;
+}
+/**
+ * An encoder for a specific shape of node.
+ *
+ * Can only be used with compatible nodes.
+ */
+export interface NodeEncoder extends Encoder {
+    /**
+     * @param cursor - in Nodes mode. Does not move cursor.
+     */
+    encodeNode(cursor: ITreeCursorSynchronous, cache: EncoderCache, outputBuffer: BufferFormat): void;
+}
+/**
+ * Like {@link NodeEncoder}, except encodes a run of nodes.
+ */
+export interface NodesEncoder extends Encoder {
+    /**
+     * @param cursor - in Nodes mode. Moves cursor however many nodes it encodes.
+     */
+    encodeNodes(cursor: ITreeCursorSynchronous, cache: EncoderCache, outputBuffer: BufferFormat): void;
+}
+/**
+ * Like {@link NodeEncoder}, except encodes a field.
+ */
+export interface FieldEncoder extends Encoder {
+    /**
+     * @param cursor - in Fields mode. Encodes entire field.
+     */
+    encodeField(cursor: ITreeCursorSynchronous, cache: EncoderCache, outputBuffer: BufferFormat): void;
+}
+/**
+ * Makes a {@link FieldEncoder} which runs `encoder` on every node in the field.
+ * This does not encode the number nodes: the user of this may need to encode that elsewhere.
+ */
+export declare function asFieldEncoder(encoder: NodeEncoder): FieldEncoder;
+/**
+ * Adapt a {@link NodeEncoder} to a {@link NodesEncoder} which invokes `encoder` once.
+ */
+export declare function asNodesEncoder(encoder: NodeEncoder): NodesEncoder;
+/**
+ * Encodes a chunk with {@link EncodedAnyShape} by prefixing the data with its shape.
+ */
+export declare class AnyShape extends ShapeGeneric<EncodedChunkShape> {
+    private constructor();
+    static readonly instance: AnyShape;
+    encodeShape(identifiers: DeduplicationTable<string>, shapes: DeduplicationTable<Shape>): EncodedChunkShape;
+    count(identifiers: Counter<string>, shapes: (shape: Shape) => void): void;
+    static encodeField(cursor: ITreeCursorSynchronous, cache: EncoderCache, outputBuffer: BufferFormat, shape: FieldEncoder): void;
+    static encodeNode(cursor: ITreeCursorSynchronous, cache: EncoderCache, outputBuffer: BufferFormat, shape: NodeEncoder): void;
+    static encodeNodes(cursor: ITreeCursorSynchronous, cache: EncoderCache, outputBuffer: BufferFormat, shape: NodesEncoder): void;
+}
+/**
+ * Encodes a single node polymorphically.
+ */
+export declare const anyNodeEncoder: NodeEncoder;
+/**
+ * Encodes a field polymorphically.
+ */
+export declare const anyFieldEncoder: FieldEncoder;
+/**
+ * Encodes a chunk using {@link EncodedInlineArray}.
+ */
+export declare class InlineArrayShape extends ShapeGeneric<EncodedChunkShape> implements NodesEncoder, FieldEncoder {
+    readonly length: number;
+    readonly inner: NodesEncoder;
+    static readonly empty: InlineArrayShape;
+    /**
+     * @param length - number of invocations of `inner`.
+     */
+    constructor(length: number, inner: NodesEncoder);
+    encodeNodes(cursor: ITreeCursorSynchronous, shapes: EncoderCache, outputBuffer: BufferFormat): void;
+    encodeField(cursor: ITreeCursorSynchronous, shapes: EncoderCache, outputBuffer: BufferFormat): void;
+    encodeShape(identifiers: DeduplicationTable<string>, shapes: DeduplicationTable<Shape>): EncodedChunkShape;
+    count(identifiers: Counter<string>, shapes: (shape: Shape) => void): void;
+    get shape(): this;
+}
+/**
+ * Encodes a field as a nested array with the {@link EncodedNestedArray} shape.
+ */
+export declare class NestedArrayShape extends ShapeGeneric<EncodedChunkShape> implements FieldEncoder {
+    readonly inner: NodeEncoder;
+    readonly shape: Shape;
+    constructor(inner: NodeEncoder);
+    encodeField(cursor: ITreeCursorSynchronous, cache: EncoderCache, outputBuffer: BufferFormat): void;
+    encodeShape(identifiers: DeduplicationTable<string>, shapes: DeduplicationTable<Shape>): EncodedChunkShape;
+    count(identifiers: Counter<string>, shapes: (shape: Shape) => void): void;
+}
+/**
+ * Encode `value` with `shape` into `outputBuffer`.
+ *
+ * Requires that `value` is compatible with `shape`.
+ */
+export declare function encodeValue(value: Value, shape: EncodedValueShape, outputBuffer: BufferFormat): void;
+export declare class EncoderCache implements TreeShaper, FieldShaper {
+    private readonly treeEncoder;
+    private readonly fieldEncoder;
+    readonly fieldShapes: ReadonlyMap<FieldKindIdentifier, FieldKind>;
+    private readonly shapesFromSchema;
+    private readonly nestedArrays;
+    constructor(treeEncoder: TreeShapePolicy, fieldEncoder: FieldShapePolicy, fieldShapes: ReadonlyMap<FieldKindIdentifier, FieldKind>);
+    shapeFromTree(schemaName: TreeNodeSchemaIdentifier): NodeEncoder;
+    nestedArray(inner: NodeEncoder): NestedArrayShape;
+    shapeFromField(field: TreeFieldStoredSchema): FieldEncoder;
+}
+export interface TreeShaper {
+    shapeFromTree(schemaName: TreeNodeSchemaIdentifier): NodeEncoder;
+}
+export interface FieldShaper {
+    shapeFromField(field: TreeFieldStoredSchema): FieldEncoder;
+}
+export type FieldShapePolicy = (treeShaper: TreeShaper, field: TreeFieldStoredSchema) => FieldEncoder;
+export type TreeShapePolicy = (fieldShaper: FieldShaper, schemaName: TreeNodeSchemaIdentifier) => NodeEncoder;
+//# sourceMappingURL=compressedEncode.d.ts.map

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

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

package/dist/feature-libraries/chunked-forest/codec/compressedEncode.js

@@ -0,0 +1,280 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncoderCache = exports.encodeValue = exports.NestedArrayShape = exports.InlineArrayShape = exports.anyFieldEncoder = exports.anyNodeEncoder = exports.AnyShape = exports.asNodesEncoder = exports.asFieldEncoder = exports.compressedEncode = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const core_1 = require("../../../core");
+const util_1 = require("../../../util");
+const chunkEncodingGeneric_1 = require("./chunkEncodingGeneric");
+const format_1 = require("./format");
+/**
+ * Encode data from `FieldBatch` in into an `EncodedChunk`.
+ *
+ * Optimized for encoded size and encoding performance.
+ *
+ * Most of the compression strategy comes from the policy provided via `cache`.
+ */
+function compressedEncode(fieldBatch, cache) {
+    const batchBuffer = [];
+    // Populate buffer, including shape and identifier references
+    for (const cursor of fieldBatch) {
+        const buffer = [];
+        exports.anyFieldEncoder.encodeField(cursor, cache, buffer);
+        batchBuffer.push(buffer);
+    }
+    return (0, chunkEncodingGeneric_1.handleShapesAndIdentifiers)(format_1.version, batchBuffer);
+}
+exports.compressedEncode = compressedEncode;
+/**
+ * Makes a {@link FieldEncoder} which runs `encoder` on every node in the field.
+ * This does not encode the number nodes: the user of this may need to encode that elsewhere.
+ */
+function asFieldEncoder(encoder) {
+    return {
+        encodeField(cursor, shapes, outputBuffer) {
+            (0, core_1.forEachNode)(cursor, () => encoder.encodeNode(cursor, shapes, outputBuffer));
+        },
+        shape: encoder.shape,
+    };
+}
+exports.asFieldEncoder = asFieldEncoder;
+/**
+ * Adapt a {@link NodeEncoder} to a {@link NodesEncoder} which invokes `encoder` once.
+ */
+function asNodesEncoder(encoder) {
+    return {
+        encodeNodes(cursor, shapes, outputBuffer) {
+            encoder.encodeNode(cursor, shapes, outputBuffer);
+            cursor.nextNode();
+        },
+        shape: encoder.shape,
+    };
+}
+exports.asNodesEncoder = asNodesEncoder;
+/**
+ * Encodes a chunk with {@link EncodedAnyShape} by prefixing the data with its shape.
+ */
+class AnyShape extends chunkEncodingGeneric_1.Shape {
+    constructor() {
+        super();
+    }
+    encodeShape(identifiers, shapes) {
+        const encodedAnyShape = 0;
+        return { d: encodedAnyShape };
+    }
+    count(identifiers, shapes) { }
+    static encodeField(cursor, cache, outputBuffer, shape) {
+        outputBuffer.push(shape.shape);
+        shape.encodeField(cursor, cache, outputBuffer);
+    }
+    static encodeNode(cursor, cache, outputBuffer, shape) {
+        outputBuffer.push(shape.shape);
+        shape.encodeNode(cursor, cache, outputBuffer);
+    }
+    static encodeNodes(cursor, cache, outputBuffer, shape) {
+        outputBuffer.push(shape.shape);
+        shape.encodeNodes(cursor, cache, outputBuffer);
+    }
+}
+exports.AnyShape = AnyShape;
+AnyShape.instance = new AnyShape();
+/**
+ * Encodes a single node polymorphically.
+ */
+exports.anyNodeEncoder = {
+    encodeNode(cursor, cache, outputBuffer) {
+        // TODO: Fast path uniform chunk content.
+        const shape = cache.shapeFromTree(cursor.type);
+        AnyShape.encodeNode(cursor, cache, outputBuffer, shape);
+    },
+    shape: AnyShape.instance,
+};
+/**
+ * Encodes a field polymorphically.
+ */
+exports.anyFieldEncoder = {
+    encodeField(cursor, cache, outputBuffer) {
+        // TODO: Fast path uniform chunks.
+        if (cursor.getFieldLength() === 0) {
+            const shape = InlineArrayShape.empty;
+            AnyShape.encodeField(cursor, cache, outputBuffer, shape);
+        }
+        else if (cursor.getFieldLength() === 1) {
+            // Fast path chunk of size one size one at least: skip nested array.
+            cursor.enterNode(0);
+            exports.anyNodeEncoder.encodeNode(cursor, cache, outputBuffer);
+            cursor.exitNode();
+        }
+        else {
+            // TODO: more efficient encoding for common cases.
+            // Could try to find more specific shape compatible with all children than `anyNodeEncoder`.
+            const shape = cache.nestedArray(exports.anyNodeEncoder);
+            AnyShape.encodeField(cursor, cache, outputBuffer, shape);
+        }
+    },
+    shape: AnyShape.instance,
+};
+/**
+ * Encodes a chunk using {@link EncodedInlineArray}.
+ */
+class InlineArrayShape extends chunkEncodingGeneric_1.Shape {
+    /**
+     * @param length - number of invocations of `inner`.
+     */
+    constructor(length, inner) {
+        super();
+        this.length = length;
+        this.inner = inner;
+    }
+    encodeNodes(cursor, shapes, outputBuffer) {
+        // Linter is wrong about this loop being for-of compatible.
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let index = 0; index < this.length; index++) {
+            this.inner.encodeNodes(cursor, shapes, outputBuffer);
+        }
+    }
+    encodeField(cursor, shapes, outputBuffer) {
+        // Its possible individual items from this array encode multiple nodes, so don't assume === here.
+        (0, core_utils_1.assert)(cursor.getFieldLength() >= this.length, 0x73c /* unexpected length for fixed length array */);
+        cursor.firstNode();
+        this.encodeNodes(cursor, shapes, outputBuffer);
+        (0, core_utils_1.assert)(cursor.mode === 1 /* CursorLocationType.Fields */, 0x73d /* should return to fields mode when finished encoding */);
+    }
+    encodeShape(identifiers, shapes) {
+        return {
+            b: {
+                length: this.length,
+                shape: shapes.valueToIndex.get(this.inner.shape) ?? (0, util_1.fail)("missing shape"),
+            },
+        };
+    }
+    count(identifiers, shapes) {
+        shapes(this.inner.shape);
+    }
+    get shape() {
+        return this;
+    }
+}
+exports.InlineArrayShape = InlineArrayShape;
+InlineArrayShape.empty = new InlineArrayShape(0, {
+    get shape() {
+        // Not actually used, makes count work without adding an additional shape.
+        return InlineArrayShape.empty;
+    },
+    encodeNodes(cursor, shapes, outputBuffer) {
+        (0, util_1.fail)("Empty array should not encode any nodes");
+    },
+});
+/**
+ * Encodes a field as a nested array with the {@link EncodedNestedArray} shape.
+ */
+class NestedArrayShape extends chunkEncodingGeneric_1.Shape {
+    constructor(inner) {
+        super();
+        this.inner = inner;
+        this.shape = this;
+    }
+    encodeField(cursor, cache, outputBuffer) {
+        const buffer = [];
+        let allNonZeroSize = true;
+        const length = cursor.getFieldLength();
+        (0, core_1.forEachNode)(cursor, () => {
+            const before = buffer.length;
+            this.inner.encodeNode(cursor, cache, buffer);
+            allNonZeroSize && (allNonZeroSize = buffer.length - before !== 0);
+        });
+        if (buffer.length === 0) {
+            // This relies on the number of inner chunks being the same as the number of nodes.
+            // If making inner a `NodesEncoder`, this code will have to be adjusted accordingly.
+            outputBuffer.push(length);
+        }
+        else {
+            (0, core_utils_1.assert)(allNonZeroSize, 0x73e /* either all or none of the members of a nested array must be 0 sized, or there is no way the decoder could process the content correctly. */);
+            outputBuffer.push(buffer);
+        }
+    }
+    encodeShape(identifiers, shapes) {
+        const shape = shapes.valueToIndex.get(this.inner.shape) ?? (0, util_1.fail)("index for shape not found in table");
+        return {
+            a: shape,
+        };
+    }
+    count(identifiers, shapes) {
+        shapes(this.inner.shape);
+    }
+}
+exports.NestedArrayShape = NestedArrayShape;
+/**
+ * Encode `value` with `shape` into `outputBuffer`.
+ *
+ * Requires that `value` is compatible with `shape`.
+ */
+function encodeValue(value, shape, outputBuffer) {
+    if (shape === undefined) {
+        if (value !== undefined) {
+            outputBuffer.push(true, value);
+        }
+        else {
+            outputBuffer.push(false);
+        }
+    }
+    else {
+        if (shape === true) {
+            (0, core_utils_1.assert)(value !== undefined, 0x78d /* required value must not be missing */);
+            outputBuffer.push(value);
+        }
+        else if (shape === false) {
+            (0, core_utils_1.assert)(value === undefined, 0x73f /* incompatible value shape: expected no value */);
+        }
+        else if (Array.isArray(shape)) {
+            (0, core_utils_1.assert)(shape.length === 1, 0x740 /* expected a single constant for value */);
+        }
+        else {
+            // EncodedCounter case:
+            (0, core_utils_1.unreachableCase)(shape, "Encoding values as deltas is not yet supported");
+        }
+    }
+}
+exports.encodeValue = encodeValue;
+class EncoderCache {
+    constructor(treeEncoder, fieldEncoder, fieldShapes) {
+        this.treeEncoder = treeEncoder;
+        this.fieldEncoder = fieldEncoder;
+        this.fieldShapes = fieldShapes;
+        this.shapesFromSchema = new Map();
+        this.nestedArrays = new Map();
+    }
+    shapeFromTree(schemaName) {
+        return (0, util_1.getOrCreate)(this.shapesFromSchema, schemaName, () => this.treeEncoder(this, schemaName));
+    }
+    nestedArray(inner) {
+        return (0, util_1.getOrCreate)(this.nestedArrays, inner, () => new NestedArrayShape(inner));
+    }
+    shapeFromField(field) {
+        return new LazyFieldEncoder(this, field, this.fieldEncoder);
+    }
+}
+exports.EncoderCache = EncoderCache;
+class LazyFieldEncoder {
+    constructor(cache, field, fieldEncoder) {
+        this.cache = cache;
+        this.field = field;
+        this.fieldEncoder = fieldEncoder;
+    }
+    encodeField(cursor, cache, outputBuffer) {
+        this.encoder.encodeField(cursor, cache, outputBuffer);
+    }
+    get encoder() {
+        if (this.encoderLazy === undefined) {
+            this.encoderLazy = this.fieldEncoder(this.cache, this.field);
+        }
+        return this.encoderLazy;
+    }
+    get shape() {
+        return this.encoder.shape;
+    }
+}
+//# sourceMappingURL=compressedEncode.js.map

package/dist/feature-libraries/chunked-forest/codec/compressedEncode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compressedEncode.js","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/compressedEncode.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, unreachableCase } from \"@fluidframework/core-utils\";\nimport {\n\tCursorLocationType,\n\tFieldKey,\n\tTreeFieldStoredSchema,\n\tITreeCursorSynchronous,\n\tTreeNodeSchemaIdentifier,\n\tValue,\n\tforEachNode,\n\tFieldKindIdentifier,\n} from \"../../../core\";\nimport { fail, getOrCreate } from \"../../../util\";\nimport { type FieldKind } from \"../../modular-schema\";\nimport {\n\tBufferFormat as BufferFormatGeneric,\n\tShape as ShapeGeneric,\n\thandleShapesAndIdentifiers,\n} from \"./chunkEncodingGeneric\";\nimport { Counter, DeduplicationTable } from \"./chunkCodecUtilities\";\nimport {\n\tversion,\n\tEncodedChunkShape,\n\tEncodedValueShape,\n\tEncodedAnyShape,\n\tEncodedNestedArray,\n\tEncodedFieldBatch,\n} from \"./format\";\nimport { FieldBatch } from \"./fieldBatch\";\n\n/**\n * Encode data from `FieldBatch` in into an `EncodedChunk`.\n *\n * Optimized for encoded size and encoding performance.\n *\n * Most of the compression strategy comes from the policy provided via `cache`.\n */\nexport function compressedEncode(fieldBatch: FieldBatch, cache: EncoderCache): EncodedFieldBatch {\n\tconst batchBuffer: BufferFormat[] = [];\n\n\t// Populate buffer, including shape and identifier references\n\tfor (const cursor of fieldBatch) {\n\t\tconst buffer: BufferFormat = [];\n\t\tanyFieldEncoder.encodeField(cursor, cache, buffer);\n\t\tbatchBuffer.push(buffer);\n\t}\n\treturn handleShapesAndIdentifiers(version, batchBuffer);\n}\n\nexport type BufferFormat = BufferFormatGeneric<EncodedChunkShape>;\nexport type Shape = ShapeGeneric<EncodedChunkShape>;\n\n/**\n * Like {@link FieldEncoder}, except data will be prefixed with the key.\n */\nexport interface KeyedFieldEncoder {\n\treadonly key: FieldKey;\n\treadonly shape: FieldEncoder;\n}\n\n/**\n * An encoder with an associated shape.\n */\nexport interface Encoder {\n\t/**\n\t * The shape which describes how the encoded data is laid out.\n\t * Used by decoders to interpret the output of `encodeNode`.\n\t */\n\treadonly shape: Shape;\n}\n\n/**\n * An encoder for a specific shape of node.\n *\n * Can only be used with compatible nodes.\n */\nexport interface NodeEncoder extends Encoder {\n\t/**\n\t * @param cursor - in Nodes mode. Does not move cursor.\n\t */\n\tencodeNode(\n\t\tcursor: ITreeCursorSynchronous,\n\t\tcache: EncoderCache,\n\t\toutputBuffer: BufferFormat,\n\t): void;\n}\n\n/**\n * Like {@link NodeEncoder}, except encodes a run of nodes.\n */\nexport interface NodesEncoder extends Encoder {\n\t/**\n\t * @param cursor - in Nodes mode. Moves cursor however many nodes it encodes.\n\t */\n\tencodeNodes(\n\t\tcursor: ITreeCursorSynchronous,\n\t\tcache: EncoderCache,\n\t\toutputBuffer: BufferFormat,\n\t): void;\n}\n\n/**\n * Like {@link NodeEncoder}, except encodes a field.\n */\nexport interface FieldEncoder extends Encoder {\n\t/**\n\t * @param cursor - in Fields mode. Encodes entire field.\n\t */\n\tencodeField(\n\t\tcursor: ITreeCursorSynchronous,\n\t\tcache: EncoderCache,\n\t\toutputBuffer: BufferFormat,\n\t): void;\n}\n\n/**\n * Makes a {@link FieldEncoder} which runs `encoder` on every node in the field.\n * This does not encode the number nodes: the user of this may need to encode that elsewhere.\n */\nexport function asFieldEncoder(encoder: NodeEncoder): FieldEncoder {\n\treturn {\n\t\tencodeField(\n\t\t\tcursor: ITreeCursorSynchronous,\n\t\t\tshapes: EncoderCache,\n\t\t\toutputBuffer: BufferFormat,\n\t\t): void {\n\t\t\tforEachNode(cursor, () => encoder.encodeNode(cursor, shapes, outputBuffer));\n\t\t},\n\t\tshape: encoder.shape,\n\t};\n}\n\n/**\n * Adapt a {@link NodeEncoder} to a {@link NodesEncoder} which invokes `encoder` once.\n */\nexport function asNodesEncoder(encoder: NodeEncoder): NodesEncoder {\n\treturn {\n\t\tencodeNodes(\n\t\t\tcursor: ITreeCursorSynchronous,\n\t\t\tshapes: EncoderCache,\n\t\t\toutputBuffer: BufferFormat,\n\t\t): void {\n\t\t\tencoder.encodeNode(cursor, shapes, outputBuffer);\n\t\t\tcursor.nextNode();\n\t\t},\n\t\tshape: encoder.shape,\n\t};\n}\n\n/**\n * Encodes a chunk with {@link EncodedAnyShape} by prefixing the data with its shape.\n */\nexport class AnyShape extends ShapeGeneric<EncodedChunkShape> {\n\tprivate constructor() {\n\t\tsuper();\n\t}\n\tpublic static readonly instance = new AnyShape();\n\n\tpublic encodeShape(\n\t\tidentifiers: DeduplicationTable<string>,\n\t\tshapes: DeduplicationTable<Shape>,\n\t): EncodedChunkShape {\n\t\tconst encodedAnyShape: EncodedAnyShape = 0;\n\t\treturn { d: encodedAnyShape };\n\t}\n\n\tpublic count(identifiers: Counter<string>, shapes: (shape: Shape) => void): void {}\n\n\tpublic static encodeField(\n\t\tcursor: ITreeCursorSynchronous,\n\t\tcache: EncoderCache,\n\t\toutputBuffer: BufferFormat,\n\t\tshape: FieldEncoder,\n\t) {\n\t\toutputBuffer.push(shape.shape);\n\t\tshape.encodeField(cursor, cache, outputBuffer);\n\t}\n\n\tpublic static encodeNode(\n\t\tcursor: ITreeCursorSynchronous,\n\t\tcache: EncoderCache,\n\t\toutputBuffer: BufferFormat,\n\t\tshape: NodeEncoder,\n\t) {\n\t\toutputBuffer.push(shape.shape);\n\t\tshape.encodeNode(cursor, cache, outputBuffer);\n\t}\n\n\tpublic static encodeNodes(\n\t\tcursor: ITreeCursorSynchronous,\n\t\tcache: EncoderCache,\n\t\toutputBuffer: BufferFormat,\n\t\tshape: NodesEncoder,\n\t) {\n\t\toutputBuffer.push(shape.shape);\n\t\tshape.encodeNodes(cursor, cache, outputBuffer);\n\t}\n}\n\n/**\n * Encodes a single node polymorphically.\n */\nexport const anyNodeEncoder: NodeEncoder = {\n\tencodeNode(\n\t\tcursor: ITreeCursorSynchronous,\n\t\tcache: EncoderCache,\n\t\toutputBuffer: BufferFormat,\n\t): void {\n\t\t// TODO: Fast path uniform chunk content.\n\t\tconst shape = cache.shapeFromTree(cursor.type);\n\t\tAnyShape.encodeNode(cursor, cache, outputBuffer, shape);\n\t},\n\n\tshape: AnyShape.instance,\n};\n\n/**\n * Encodes a field polymorphically.\n */\nexport const anyFieldEncoder: FieldEncoder = {\n\tencodeField(\n\t\tcursor: ITreeCursorSynchronous,\n\t\tcache: EncoderCache,\n\t\toutputBuffer: BufferFormat,\n\t): void {\n\t\t// TODO: Fast path uniform chunks.\n\n\t\tif (cursor.getFieldLength() === 0) {\n\t\t\tconst shape = InlineArrayShape.empty;\n\t\t\tAnyShape.encodeField(cursor, cache, outputBuffer, shape);\n\t\t} else if (cursor.getFieldLength() === 1) {\n\t\t\t// Fast path chunk of size one size one at least: skip nested array.\n\t\t\tcursor.enterNode(0);\n\t\t\tanyNodeEncoder.encodeNode(cursor, cache, outputBuffer);\n\t\t\tcursor.exitNode();\n\t\t} else {\n\t\t\t// TODO: more efficient encoding for common cases.\n\t\t\t// Could try to find more specific shape compatible with all children than `anyNodeEncoder`.\n\n\t\t\tconst shape = cache.nestedArray(anyNodeEncoder);\n\t\t\tAnyShape.encodeField(cursor, cache, outputBuffer, shape);\n\t\t}\n\t},\n\n\tshape: AnyShape.instance,\n};\n\n/**\n * Encodes a chunk using {@link EncodedInlineArray}.\n */\nexport class InlineArrayShape\n\textends ShapeGeneric<EncodedChunkShape>\n\timplements NodesEncoder, FieldEncoder\n{\n\tpublic static readonly empty: InlineArrayShape = new InlineArrayShape(0, {\n\t\tget shape() {\n\t\t\t// Not actually used, makes count work without adding an additional shape.\n\t\t\treturn InlineArrayShape.empty;\n\t\t},\n\t\tencodeNodes(\n\t\t\tcursor: ITreeCursorSynchronous,\n\t\t\tshapes: EncoderCache,\n\t\t\toutputBuffer: BufferFormat,\n\t\t): void {\n\t\t\tfail(\"Empty array should not encode any nodes\");\n\t\t},\n\t});\n\n\t/**\n\t * @param length - number of invocations of `inner`.\n\t */\n\tpublic constructor(\n\t\tpublic readonly length: number,\n\t\tpublic readonly inner: NodesEncoder,\n\t) {\n\t\tsuper();\n\t}\n\n\tpublic encodeNodes(\n\t\tcursor: ITreeCursorSynchronous,\n\t\tshapes: EncoderCache,\n\t\toutputBuffer: BufferFormat,\n\t): void {\n\t\t// Linter is wrong about this loop being for-of compatible.\n\t\t// eslint-disable-next-line @typescript-eslint/prefer-for-of\n\t\tfor (let index = 0; index < this.length; index++) {\n\t\t\tthis.inner.encodeNodes(cursor, shapes, outputBuffer);\n\t\t}\n\t}\n\n\tpublic encodeField(\n\t\tcursor: ITreeCursorSynchronous,\n\t\tshapes: EncoderCache,\n\t\toutputBuffer: BufferFormat,\n\t): void {\n\t\t// Its possible individual items from this array encode multiple nodes, so don't assume === here.\n\t\tassert(\n\t\t\tcursor.getFieldLength() >= this.length,\n\t\t\t0x73c /* unexpected length for fixed length array */,\n\t\t);\n\t\tcursor.firstNode();\n\t\tthis.encodeNodes(cursor, shapes, outputBuffer);\n\t\tassert(\n\t\t\tcursor.mode === CursorLocationType.Fields,\n\t\t\t0x73d /* should return to fields mode when finished encoding */,\n\t\t);\n\t}\n\n\tpublic encodeShape(\n\t\tidentifiers: DeduplicationTable<string>,\n\t\tshapes: DeduplicationTable<Shape>,\n\t): EncodedChunkShape {\n\t\treturn {\n\t\t\tb: {\n\t\t\t\tlength: this.length,\n\t\t\t\tshape: shapes.valueToIndex.get(this.inner.shape) ?? fail(\"missing shape\"),\n\t\t\t},\n\t\t};\n\t}\n\n\tpublic count(identifiers: Counter<string>, shapes: (shape: Shape) => void): void {\n\t\tshapes(this.inner.shape);\n\t}\n\n\tpublic get shape() {\n\t\treturn this;\n\t}\n}\n\n/**\n * Encodes a field as a nested array with the {@link EncodedNestedArray} shape.\n */\nexport class NestedArrayShape extends ShapeGeneric<EncodedChunkShape> implements FieldEncoder {\n\tpublic readonly shape: Shape;\n\n\tpublic constructor(public readonly inner: NodeEncoder) {\n\t\tsuper();\n\t\tthis.shape = this;\n\t}\n\n\tpublic encodeField(\n\t\tcursor: ITreeCursorSynchronous,\n\t\tcache: EncoderCache,\n\t\toutputBuffer: BufferFormat,\n\t): void {\n\t\tconst buffer: BufferFormat = [];\n\t\tlet allNonZeroSize = true;\n\t\tconst length = cursor.getFieldLength();\n\t\tforEachNode(cursor, () => {\n\t\t\tconst before = buffer.length;\n\t\t\tthis.inner.encodeNode(cursor, cache, buffer);\n\t\t\tallNonZeroSize &&= buffer.length - before !== 0;\n\t\t});\n\t\tif (buffer.length === 0) {\n\t\t\t// This relies on the number of inner chunks being the same as the number of nodes.\n\t\t\t// If making inner a `NodesEncoder`, this code will have to be adjusted accordingly.\n\t\t\toutputBuffer.push(length);\n\t\t} else {\n\t\t\tassert(\n\t\t\t\tallNonZeroSize,\n\t\t\t\t0x73e /* either all or none of the members of a nested array must be 0 sized, or there is no way the decoder could process the content correctly. */,\n\t\t\t);\n\t\t\toutputBuffer.push(buffer);\n\t\t}\n\t}\n\n\tpublic encodeShape(\n\t\tidentifiers: DeduplicationTable<string>,\n\t\tshapes: DeduplicationTable<Shape>,\n\t): EncodedChunkShape {\n\t\tconst shape: EncodedNestedArray =\n\t\t\tshapes.valueToIndex.get(this.inner.shape) ?? fail(\"index for shape not found in table\");\n\t\treturn {\n\t\t\ta: shape,\n\t\t};\n\t}\n\n\tpublic count(identifiers: Counter<string>, shapes: (shape: Shape) => void): void {\n\t\tshapes(this.inner.shape);\n\t}\n}\n\n/**\n * Encode `value` with `shape` into `outputBuffer`.\n *\n * Requires that `value` is compatible with `shape`.\n */\nexport function encodeValue(\n\tvalue: Value,\n\tshape: EncodedValueShape,\n\toutputBuffer: BufferFormat,\n): void {\n\tif (shape === undefined) {\n\t\tif (value !== undefined) {\n\t\t\toutputBuffer.push(true, value);\n\t\t} else {\n\t\t\toutputBuffer.push(false);\n\t\t}\n\t} else {\n\t\tif (shape === true) {\n\t\t\tassert(value !== undefined, 0x78d /* required value must not be missing */);\n\t\t\toutputBuffer.push(value);\n\t\t} else if (shape === false) {\n\t\t\tassert(value === undefined, 0x73f /* incompatible value shape: expected no value */);\n\t\t} else if (Array.isArray(shape)) {\n\t\t\tassert(shape.length === 1, 0x740 /* expected a single constant for value */);\n\t\t} else {\n\t\t\t// EncodedCounter case:\n\t\t\tunreachableCase(shape, \"Encoding values as deltas is not yet supported\");\n\t\t}\n\t}\n}\n\nexport class EncoderCache implements TreeShaper, FieldShaper {\n\tprivate readonly shapesFromSchema: Map<TreeNodeSchemaIdentifier, NodeEncoder> = new Map();\n\tprivate readonly nestedArrays: Map<NodeEncoder, NestedArrayShape> = new Map();\n\tpublic constructor(\n\t\tprivate readonly treeEncoder: TreeShapePolicy,\n\t\tprivate readonly fieldEncoder: FieldShapePolicy,\n\t\tpublic readonly fieldShapes: ReadonlyMap<FieldKindIdentifier, FieldKind>,\n\t) {}\n\n\tpublic shapeFromTree(schemaName: TreeNodeSchemaIdentifier): NodeEncoder {\n\t\treturn getOrCreate(this.shapesFromSchema, schemaName, () =>\n\t\t\tthis.treeEncoder(this, schemaName),\n\t\t);\n\t}\n\n\tpublic nestedArray(inner: NodeEncoder): NestedArrayShape {\n\t\treturn getOrCreate(this.nestedArrays, inner, () => new NestedArrayShape(inner));\n\t}\n\n\tpublic shapeFromField(field: TreeFieldStoredSchema): FieldEncoder {\n\t\treturn new LazyFieldEncoder(this, field, this.fieldEncoder);\n\t}\n}\n\nexport interface TreeShaper {\n\tshapeFromTree(schemaName: TreeNodeSchemaIdentifier): NodeEncoder;\n}\n\nexport interface FieldShaper {\n\tshapeFromField(field: TreeFieldStoredSchema): FieldEncoder;\n}\n\nexport type FieldShapePolicy = (\n\ttreeShaper: TreeShaper,\n\tfield: TreeFieldStoredSchema,\n) => FieldEncoder;\n\nexport type TreeShapePolicy = (\n\tfieldShaper: FieldShaper,\n\tschemaName: TreeNodeSchemaIdentifier,\n) => NodeEncoder;\n\nclass LazyFieldEncoder implements FieldEncoder {\n\tprivate encoderLazy: FieldEncoder | undefined;\n\n\tpublic constructor(\n\t\tpublic readonly cache: TreeShaper,\n\t\tpublic readonly field: TreeFieldStoredSchema,\n\t\tprivate readonly fieldEncoder: FieldShapePolicy,\n\t) {}\n\tpublic encodeField(\n\t\tcursor: ITreeCursorSynchronous,\n\t\tcache: EncoderCache,\n\t\toutputBuffer: BufferFormat,\n\t): void {\n\t\tthis.encoder.encodeField(cursor, cache, outputBuffer);\n\t}\n\n\tprivate get encoder(): FieldEncoder {\n\t\tif (this.encoderLazy === undefined) {\n\t\t\tthis.encoderLazy = this.fieldEncoder(this.cache, this.field);\n\t\t}\n\t\treturn this.encoderLazy;\n\t}\n\n\tpublic get shape(): Shape {\n\t\treturn this.encoder.shape;\n\t}\n}\n"]}

package/dist/feature-libraries/chunked-forest/codec/fieldBatch.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { ITreeCursorSynchronous } from "../../../core";
+/**
+ * Collection of field cursors to compress as a batch.
+ * Cursors must be in fields mode.
+ */
+export type FieldBatch = readonly ITreeCursorSynchronous[];
+//# sourceMappingURL=fieldBatch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fieldBatch.d.ts","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/fieldBatch.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAEvD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,sBAAsB,EAAE,CAAC"}