@fluidframework/merge-tree 2.0.0-internal.8.0.0 → 2.0.0-rc.1.0.0

package/lib/{opBuilder.js → opBuilder.mjs}

@@ -1,11 +1,8 @@
-"use strict";
 /*!
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createGroupOp = exports.createInsertOp = exports.createInsertSegmentOp = exports.createObliterateRangeOp = exports.createRemoveRangeOp = exports.createAnnotateRangeOp = exports.createAnnotateMarkerOp = void 0;
-const ops_1 = require("./ops");
+import { MergeTreeDeltaType, } from "./ops.mjs";
 /**
  * Creates the op for annotating the markers with the provided properties
  * @param marker - The marker to annotate
@@ -14,7 +11,7 @@ const ops_1 = require("./ops");
  *
  * @internal
  */
-function createAnnotateMarkerOp(marker, props) {
+export function createAnnotateMarkerOp(marker, props) {
     const id = marker.getId();
     if (!id) {
         return undefined;
@@ -23,10 +20,9 @@ function createAnnotateMarkerOp(marker, props) {
         props,
         relativePos1: { id, before: true },
         relativePos2: { id },
-        type: ops_1.MergeTreeDeltaType.ANNOTATE,
+        type: MergeTreeDeltaType.ANNOTATE,
     };
 }
-exports.createAnnotateMarkerOp = createAnnotateMarkerOp;
 /**
  * Creates the op for annotating the range with the provided properties
  * @param start - The inclusive start position of the range to annotate
@@ -36,15 +32,14 @@ exports.createAnnotateMarkerOp = createAnnotateMarkerOp;
  *
  * @internal
  */
-function createAnnotateRangeOp(start, end, props) {
+export function createAnnotateRangeOp(start, end, props) {
     return {
         pos1: start,
         pos2: end,
         props,
-        type: ops_1.MergeTreeDeltaType.ANNOTATE,
+        type: MergeTreeDeltaType.ANNOTATE,
     };
 }
-exports.createAnnotateRangeOp = createAnnotateRangeOp;
 /**
  * Creates the op to remove a range
  *
@@ -53,14 +48,13 @@ exports.createAnnotateRangeOp = createAnnotateRangeOp;
  *
  * @internal
  */
-function createRemoveRangeOp(start, end) {
+export function createRemoveRangeOp(start, end) {
     return {
         pos1: start,
         pos2: end,
-        type: ops_1.MergeTreeDeltaType.REMOVE,
+        type: MergeTreeDeltaType.REMOVE,
     };
 }
-exports.createRemoveRangeOp = createRemoveRangeOp;
 /**
  * Creates the op to obliterate a range
  *
@@ -70,14 +64,13 @@ exports.createRemoveRangeOp = createRemoveRangeOp;
  * @internal
  */
 // eslint-disable-next-line import/no-deprecated
-function createObliterateRangeOp(start, end) {
+export function createObliterateRangeOp(start, end) {
     return {
         pos1: start,
         pos2: end,
-        type: ops_1.MergeTreeDeltaType.OBLITERATE,
+        type: MergeTreeDeltaType.OBLITERATE,
     };
 }
-exports.createObliterateRangeOp = createObliterateRangeOp;
 /**
  *
  * @param pos - The position to insert the segment at
@@ -85,21 +78,19 @@ exports.createObliterateRangeOp = createObliterateRangeOp;
  *
  * @internal
  */
-function createInsertSegmentOp(pos, segment) {
+export function createInsertSegmentOp(pos, segment) {
     return createInsertOp(pos, segment.toJSONObject());
 }
-exports.createInsertSegmentOp = createInsertSegmentOp;
 /**
  * @internal
  */
-function createInsertOp(pos, segSpec) {
+export function createInsertOp(pos, segSpec) {
     return {
         pos1: pos,
         seg: segSpec,
-        type: ops_1.MergeTreeDeltaType.INSERT,
+        type: MergeTreeDeltaType.INSERT,
     };
 }
-exports.createInsertOp = createInsertOp;
 /**
  *
  * @param ops - The ops to group
@@ -112,11 +103,10 @@ exports.createInsertOp = createInsertOp;
  * @internal
  */
 // eslint-disable-next-line import/no-deprecated
-function createGroupOp(...ops) {
+export function createGroupOp(...ops) {
     return {
         ops,
-        type: ops_1.MergeTreeDeltaType.GROUP,
+        type: MergeTreeDeltaType.GROUP,
     };
 }
-exports.createGroupOp = createGroupOp;
-//# sourceMappingURL=opBuilder.js.map
+//# sourceMappingURL=opBuilder.mjs.map

package/lib/opBuilder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"opBuilder.mjs","sourceRoot":"","sources":["../src/opBuilder.ts"],"names":[],"mappings":"AAAA;;;GAGG;OAGI,EAMN,kBAAkB,GAIlB;AAGD;;;;;;;GAOG;AACH,MAAM,UAAU,sBAAsB,CACrC,MAAc,EACd,KAAkB;IAElB,MAAM,EAAE,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC;IAC1B,IAAI,CAAC,EAAE,EAAE;QACR,OAAO,SAAS,CAAC;KACjB;IAED,OAAO;QACN,KAAK;QACL,YAAY,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;QAClC,YAAY,EAAE,EAAE,EAAE,EAAE;QACpB,IAAI,EAAE,kBAAkB,CAAC,QAAQ;KACjC,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,qBAAqB,CACpC,KAAa,EACb,GAAW,EACX,KAAkB;IAElB,OAAO;QACN,IAAI,EAAE,KAAK;QACX,IAAI,EAAE,GAAG;QACT,KAAK;QACL,IAAI,EAAE,kBAAkB,CAAC,QAAQ;KACjC,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAa,EAAE,GAAW;IAC7D,OAAO;QACN,IAAI,EAAE,KAAK;QACX,IAAI,EAAE,GAAG;QACT,IAAI,EAAE,kBAAkB,CAAC,MAAM;KAC/B,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,gDAAgD;AAChD,MAAM,UAAU,uBAAuB,CAAC,KAAa,EAAE,GAAW;IACjE,OAAO;QACN,IAAI,EAAE,KAAK;QACX,IAAI,EAAE,GAAG;QACT,IAAI,EAAE,kBAAkB,CAAC,UAAU;KACnC,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAW,EAAE,OAAiB;IACnE,OAAO,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;AACpD,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc,CAAC,GAAW,EAAE,OAAY;IACvD,OAAO;QACN,IAAI,EAAE,GAAG;QACT,GAAG,EAAE,OAAO;QACZ,IAAI,EAAE,kBAAkB,CAAC,MAAM;KAC/B,CAAC;AACH,CAAC;AAED;;;;;;;;;;GAUG;AACH,gDAAgD;AAChD,MAAM,UAAU,aAAa,CAAC,GAAG,GAAwB;IACxD,OAAO;QACN,GAAG;QACH,IAAI,EAAE,kBAAkB,CAAC,KAAK;KAC9B,CAAC;AACH,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { ISegment, Marker } from \"./mergeTreeNodes\";\nimport {\n\tIMergeTreeAnnotateMsg,\n\t// eslint-disable-next-line import/no-deprecated\n\tIMergeTreeGroupMsg,\n\tIMergeTreeInsertMsg,\n\tIMergeTreeRemoveMsg,\n\tMergeTreeDeltaType,\n\tIMergeTreeDeltaOp,\n\t// eslint-disable-next-line import/no-deprecated\n\tIMergeTreeObliterateMsg,\n} from \"./ops\";\nimport { PropertySet } from \"./properties\";\n\n/**\n * Creates the op for annotating the markers with the provided properties\n * @param marker - The marker to annotate\n * @param props - The properties to annotate the marker with\n * @returns The annotate op\n *\n * @internal\n */\nexport function createAnnotateMarkerOp(\n\tmarker: Marker,\n\tprops: PropertySet,\n): IMergeTreeAnnotateMsg | undefined {\n\tconst id = marker.getId();\n\tif (!id) {\n\t\treturn undefined;\n\t}\n\n\treturn {\n\t\tprops,\n\t\trelativePos1: { id, before: true },\n\t\trelativePos2: { id },\n\t\ttype: MergeTreeDeltaType.ANNOTATE,\n\t};\n}\n\n/**\n * Creates the op for annotating the range with the provided properties\n * @param start - The inclusive start position of the range to annotate\n * @param end - The exclusive end position of the range to annotate\n * @param props - The properties to annotate the range with\n * @returns The annotate op\n *\n * @internal\n */\nexport function createAnnotateRangeOp(\n\tstart: number,\n\tend: number,\n\tprops: PropertySet,\n): IMergeTreeAnnotateMsg {\n\treturn {\n\t\tpos1: start,\n\t\tpos2: end,\n\t\tprops,\n\t\ttype: MergeTreeDeltaType.ANNOTATE,\n\t};\n}\n\n/**\n * Creates the op to remove a range\n *\n * @param start - The inclusive start of the range to remove\n * @param end - The exclusive end of the range to remove\n *\n * @internal\n */\nexport function createRemoveRangeOp(start: number, end: number): IMergeTreeRemoveMsg {\n\treturn {\n\t\tpos1: start,\n\t\tpos2: end,\n\t\ttype: MergeTreeDeltaType.REMOVE,\n\t};\n}\n\n/**\n * Creates the op to obliterate a range\n *\n * @param start - The inclusive start of the range to obliterate\n * @param end - The exclusive end of the range to obliterate\n *\n * @internal\n */\n// eslint-disable-next-line import/no-deprecated\nexport function createObliterateRangeOp(start: number, end: number): IMergeTreeObliterateMsg {\n\treturn {\n\t\tpos1: start,\n\t\tpos2: end,\n\t\ttype: MergeTreeDeltaType.OBLITERATE,\n\t};\n}\n\n/**\n *\n * @param pos - The position to insert the segment at\n * @param segment - The segment to insert\n *\n * @internal\n */\nexport function createInsertSegmentOp(pos: number, segment: ISegment): IMergeTreeInsertMsg {\n\treturn createInsertOp(pos, segment.toJSONObject());\n}\n\n/**\n * @internal\n */\nexport function createInsertOp(pos: number, segSpec: any): IMergeTreeInsertMsg {\n\treturn {\n\t\tpos1: pos,\n\t\tseg: segSpec,\n\t\ttype: MergeTreeDeltaType.INSERT,\n\t};\n}\n\n/**\n *\n * @param ops - The ops to group\n *\n * @deprecated The ability to create group ops will be removed in an upcoming\n * release, as group ops are redundant with he native batching capabilities of\n * the runtime\n *\n * @deprecated The ability to create group ops will be removed in an upcoming release, as group ops are redundant with he native batching capabilities of the runtime\n * @internal\n */\n// eslint-disable-next-line import/no-deprecated\nexport function createGroupOp(...ops: IMergeTreeDeltaOp[]): IMergeTreeGroupMsg {\n\treturn {\n\t\tops,\n\t\ttype: MergeTreeDeltaType.GROUP,\n\t};\n}\n"]}

package/lib/{ops.d.ts → ops.d.mts}

@@ -9,7 +9,7 @@
 export declare enum ReferenceType {
     Simple = 0,
     /**
-     * Allows this reference to be located using the `findTile` API on merge-tree.
+     * Allows this reference to be located using the `searchForMarker` API on merge-tree.
      */
     Tile = 1,
     /**
@@ -172,4 +172,4 @@ export type IMergeTreeDeltaOp = IMergeTreeInsertMsg | IMergeTreeRemoveMsg | IMer
  * @alpha
  */
 export type IMergeTreeOp = IMergeTreeDeltaOp | IMergeTreeGroupMsg;
-//# sourceMappingURL=ops.d.ts.map
+//# sourceMappingURL=ops.d.mts.map

package/lib/ops.d.mts.map

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

package/lib/{ops.js → ops.mjs}

@@ -1,19 +1,16 @@
-"use strict";
 /*!
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MergeTreeDeltaType = exports.ReferenceType = void 0;
 /**
  * Flags enum that dictates behavior of a {@link ReferencePosition}
  * @alpha
  */
-var ReferenceType;
+export var ReferenceType;
 (function (ReferenceType) {
     ReferenceType[ReferenceType["Simple"] = 0] = "Simple";
     /**
-     * Allows this reference to be located using the `findTile` API on merge-tree.
+     * Allows this reference to be located using the `searchForMarker` API on merge-tree.
      */
     ReferenceType[ReferenceType["Tile"] = 1] = "Tile";
     /**
@@ -45,12 +42,12 @@ var ReferenceType;
      * This is useful for comparison/iteration purposes
      */
     ReferenceType[ReferenceType["Transient"] = 256] = "Transient";
-})(ReferenceType || (exports.ReferenceType = ReferenceType = {}));
+})(ReferenceType || (ReferenceType = {}));
 // Note: Assigned positive integers to avoid clashing with MergeTreeMaintenanceType
 /**
  * @alpha
  */
-exports.MergeTreeDeltaType = {
+export const MergeTreeDeltaType = {
     INSERT: 0,
     REMOVE: 1,
     ANNOTATE: 2,
@@ -60,4 +57,4 @@ exports.MergeTreeDeltaType = {
     GROUP: 3,
     OBLITERATE: 4,
 };
-//# sourceMappingURL=ops.js.map
+//# sourceMappingURL=ops.mjs.map

package/lib/ops.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ops.mjs","sourceRoot":"","sources":["../src/ops.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,MAAM,CAAN,IAAY,aAsCX;AAtCD,WAAY,aAAa;IACxB,qDAAY,CAAA;IACZ;;OAEG;IACH,iDAAU,CAAA;IAEV;;;;OAIG;IACH,8DAAiB,CAAA;IAEjB;;;;OAIG;IACH,0DAAe,CAAA;IAEf;;;;;;OAMG;IACH,oEAAoB,CAAA;IACpB;;OAEG;IACH,mEAAmB,CAAA;IACnB;;;OAGG;IACH,6DAAiB,CAAA;AAClB,CAAC,EAtCW,aAAa,KAAb,aAAa,QAsCxB;AASD,mFAAmF;AACnF;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IACjC,MAAM,EAAE,CAAC;IACT,MAAM,EAAE,CAAC;IACT,QAAQ,EAAE,CAAC;IACX;;OAEG;IACH,KAAK,EAAE,CAAC;IACR,UAAU,EAAE,CAAC;CACJ,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Flags enum that dictates behavior of a {@link ReferencePosition}\n * @alpha\n */\nexport enum ReferenceType {\n\tSimple = 0x0,\n\t/**\n\t * Allows this reference to be located using the `searchForMarker` API on merge-tree.\n\t */\n\tTile = 0x1,\n\n\t/**\n\t * Denotes that this reference begins the start of an interval. This is\n\t * generally not meaningful outside the context of interval collections\n\t * on SharedString.\n\t */\n\tRangeBegin = 0x10,\n\n\t/**\n\t * Denotes that this reference is the end of an interval. This is\n\t * generally not meaningful outside the context of interval collections\n\t * on SharedString.\n\t */\n\tRangeEnd = 0x20,\n\n\t/**\n\t * When a segment is marked removed (locally or with ack), this reference will slide to the first\n\t * valid option of:\n\t * 1. the start of the next furthest segment\n\t * 2. the end of the next nearest segment\n\t * 3. DetachedReferencePosition\n\t */\n\tSlideOnRemove = 0x40,\n\t/**\n\t * When a segment is marked removed (locally or with ack), this reference will remain on that segment.\n\t */\n\tStayOnRemove = 0x80,\n\t/**\n\t * Specifies that the reference position should never be added to the segment it refers to.\n\t * This is useful for comparison/iteration purposes\n\t */\n\tTransient = 0x100,\n}\n\n/**\n * @alpha\n */\nexport interface IMarkerDef {\n\trefType?: ReferenceType;\n}\n\n// Note: Assigned positive integers to avoid clashing with MergeTreeMaintenanceType\n/**\n * @alpha\n */\nexport const MergeTreeDeltaType = {\n\tINSERT: 0,\n\tREMOVE: 1,\n\tANNOTATE: 2,\n\t/**\n\t * @deprecated The ability to create group ops will be removed in an upcoming release, as group ops are redundant with he native batching capabilities of the runtime\n\t */\n\tGROUP: 3,\n\tOBLITERATE: 4,\n} as const;\n\n/**\n * @alpha\n */\nexport type MergeTreeDeltaType = (typeof MergeTreeDeltaType)[keyof typeof MergeTreeDeltaType];\n\n/**\n * @alpha\n */\nexport interface IMergeTreeDelta {\n\t/**\n\t * Type of this change.\n\t */\n\ttype: MergeTreeDeltaType;\n}\n\n/**\n * A position specified relative to a segment.\n * @alpha\n */\nexport interface IRelativePosition {\n\t/**\n\t * String identifier specifying a segment.\n\t */\n\tid?: string;\n\t/**\n\t * If true, insert before the specified segment.  If false or not defined,\n\t * insert after the specified segment.\n\t */\n\tbefore?: boolean;\n\t/**\n\t * A positive number \\>= 1.  If before is false, offset is added to the position.\n\t * If before is true, offset is subtracted from the position.\n\t */\n\toffset?: number;\n}\n\n/**\n * @alpha\n */\nexport interface IMergeTreeInsertMsg extends IMergeTreeDelta {\n\ttype: typeof MergeTreeDeltaType.INSERT;\n\tpos1?: number;\n\trelativePos1?: IRelativePosition;\n\tpos2?: number;\n\trelativePos2?: IRelativePosition;\n\tseg?: any;\n}\n\n/**\n * @alpha\n */\nexport interface IMergeTreeRemoveMsg extends IMergeTreeDelta {\n\ttype: typeof MergeTreeDeltaType.REMOVE;\n\tpos1?: number;\n\trelativePos1?: IRelativePosition;\n\tpos2?: number;\n\trelativePos2?: IRelativePosition;\n}\n\n/**\n * @deprecated We no longer intend to support this functionality and it will\n * be removed in a future release. There is no replacement for this\n * functionality.\n * @alpha\n */\nexport interface IMergeTreeObliterateMsg extends IMergeTreeDelta {\n\ttype: typeof MergeTreeDeltaType.OBLITERATE;\n\tpos1?: number;\n\t/**\n\t * This field is currently unused, but we keep it around to make the union\n\t * type of all merge-tree messages have the same fields\n\t */\n\trelativePos1?: never;\n\tpos2?: number;\n\t/**\n\t * This field is currently unused, but we keep it around to make the union\n\t * type of all merge-tree messages have the same fields\n\t */\n\trelativePos2?: never;\n}\n\n/**\n * @alpha\n */\nexport interface IMergeTreeAnnotateMsg extends IMergeTreeDelta {\n\ttype: typeof MergeTreeDeltaType.ANNOTATE;\n\tpos1?: number;\n\trelativePos1?: IRelativePosition;\n\tpos2?: number;\n\trelativePos2?: IRelativePosition;\n\tprops: Record<string, any>;\n}\n\n/**\n * @deprecated The ability to create group ops will be removed in an upcoming\n * release, as group ops are redundant with the native batching capabilities\n * of the runtime\n *\n * @alpha\n */\nexport interface IMergeTreeGroupMsg extends IMergeTreeDelta {\n\ttype: typeof MergeTreeDeltaType.GROUP;\n\tops: IMergeTreeDeltaOp[];\n}\n\n/**\n * @alpha\n */\nexport interface IJSONSegment {\n\tprops?: Record<string, any>;\n}\n\n/**\n * @alpha\n */\nexport type IMergeTreeDeltaOp =\n\t| IMergeTreeInsertMsg\n\t| IMergeTreeRemoveMsg\n\t| IMergeTreeAnnotateMsg\n\t| IMergeTreeObliterateMsg;\n\n/**\n * @alpha\n */\nexport type IMergeTreeOp = IMergeTreeDeltaOp | IMergeTreeGroupMsg;\n"]}

package/lib/{ordinal.d.ts → ordinal.d.mts}

@@ -3,4 +3,4 @@
  * Licensed under the MIT License.
  */
 export declare function computeHierarchicalOrdinal(maxCount: number, actualCount: number, parentOrdinal: string, previousOrdinal: string | undefined): string;
-//# sourceMappingURL=ordinal.d.ts.map
+//# sourceMappingURL=ordinal.d.mts.map

package/lib/ordinal.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordinal.d.mts","sourceRoot":"","sources":["../src/ordinal.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,wBAAgB,0BAA0B,CACzC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,eAAe,EAAE,MAAM,GAAG,SAAS,UAkBnC"}

package/lib/{ordinal.js → ordinal.mjs}

@@ -1,14 +1,10 @@
-"use strict";
 /*!
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeHierarchicalOrdinal = void 0;
-/* eslint-disable no-bitwise */
-const core_utils_1 = require("@fluidframework/core-utils");
-function computeHierarchicalOrdinal(maxCount, actualCount, parentOrdinal, previousOrdinal) {
-    (0, core_utils_1.assert)(maxCount <= 16 && actualCount <= maxCount, 0x3f0 /* count must be less than max, and max must be 16 or less */);
+import { assert } from "@fluidframework/core-utils";
+export function computeHierarchicalOrdinal(maxCount, actualCount, parentOrdinal, previousOrdinal) {
+    assert(maxCount <= 16 && actualCount <= maxCount, 0x3f0 /* count must be less than max, and max must be 16 or less */);
     const ordinalWidth = 1 << (maxCount - actualCount);
     let ordinal;
     if (previousOrdinal === undefined) {
@@ -21,5 +17,4 @@ function computeHierarchicalOrdinal(maxCount, actualCount, parentOrdinal, previo
     }
     return ordinal;
 }
-exports.computeHierarchicalOrdinal = computeHierarchicalOrdinal;
-//# sourceMappingURL=ordinal.js.map
+//# sourceMappingURL=ordinal.mjs.map

package/lib/ordinal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordinal.mjs","sourceRoot":"","sources":["../src/ordinal.ts"],"names":[],"mappings":"AAAA;;;GAGG;OAGI,EAAE,MAAM,EAAE,MAAM,4BAA4B;AAEnD,MAAM,UAAU,0BAA0B,CACzC,QAAgB,EAChB,WAAmB,EACnB,aAAqB,EACrB,eAAmC;IAEnC,MAAM,CACL,QAAQ,IAAI,EAAE,IAAI,WAAW,IAAI,QAAQ,EACzC,KAAK,CAAC,6DAA6D,CACnE,CAAC;IAEF,MAAM,YAAY,GAAG,CAAC,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAC;IACnD,IAAI,OAAe,CAAC;IACpB,IAAI,eAAe,KAAK,SAAS,EAAE;QAClC,OAAO,GAAG,aAAa,GAAG,MAAM,CAAC,YAAY,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC;KAChE;SAAM;QACN,MAAM,WAAW,GAAG,eAAe,CAAC,UAAU,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC3E,MAAM,YAAY,GAAG,WAAW,GAAG,YAAY,CAAC;QAChD,OAAO,GAAG,aAAa,GAAG,MAAM,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;KAC5D;IAED,OAAO,OAAO,CAAC;AAChB,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/* eslint-disable no-bitwise */\nimport { assert } from \"@fluidframework/core-utils\";\n\nexport function computeHierarchicalOrdinal(\n\tmaxCount: number,\n\tactualCount: number,\n\tparentOrdinal: string,\n\tpreviousOrdinal: string | undefined,\n) {\n\tassert(\n\t\tmaxCount <= 16 && actualCount <= maxCount,\n\t\t0x3f0 /* count must be less than max, and max must be 16 or less */,\n\t);\n\n\tconst ordinalWidth = 1 << (maxCount - actualCount);\n\tlet ordinal: string;\n\tif (previousOrdinal === undefined) {\n\t\tordinal = parentOrdinal + String.fromCharCode(ordinalWidth - 1);\n\t} else {\n\t\tconst prevOrdCode = previousOrdinal.charCodeAt(previousOrdinal.length - 1);\n\t\tconst localOrdinal = prevOrdCode + ordinalWidth;\n\t\tordinal = parentOrdinal + String.fromCharCode(localOrdinal);\n\t}\n\n\treturn ordinal;\n}\n"]}

package/lib/{partialLengths.d.ts → partialLengths.d.mts}

@@ -2,9 +2,9 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { RedBlackTree } from "./collections";
-import { MergeTree } from "./mergeTree";
-import { CollaborationWindow, IMergeBlock, ISegment } from "./mergeTreeNodes";
+import { RedBlackTree } from "./collections/index.mjs";
+import { MergeTree } from "./mergeTree.mjs";
+import { CollaborationWindow, IMergeBlock, ISegment } from "./mergeTreeNodes.mjs";
 interface IOverlapClient {
     clientId: number;
     seglen: number;
@@ -273,4 +273,4 @@ export declare function verify(partialSeqLengths: PartialSequenceLengths): void;
  */
 export declare function combineOverlapClients(a: PartialSequenceLength, b: PartialSequenceLength): void;
 export {};
-//# sourceMappingURL=partialLengths.d.ts.map
+//# sourceMappingURL=partialLengths.d.mts.map

package/lib/partialLengths.d.mts.map

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

package/lib/{partialLengths.js → partialLengths.mjs}

@@ -1,18 +1,14 @@
-"use strict";
 /*!
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.combineOverlapClients = exports.verify = exports.verifyExpected = exports.PartialSequenceLengths = void 0;
-const core_utils_1 = require("@fluidframework/core-utils");
-const collections_1 = require("./collections");
-const constants_1 = require("./constants");
-const mergeTreeNodes_1 = require("./mergeTreeNodes");
+import { assert } from "@fluidframework/core-utils";
+import { RedBlackTree } from "./collections/index.mjs";
+import { UnassignedSequenceNumber } from "./constants.mjs";
+import { compareNumbers, toMoveInfo, seqLTE, toRemovalInfo, } from "./mergeTreeNodes.mjs";
+import { SortedSet } from "./sortedSet.mjs";
 // eslint-disable-next-line import/no-deprecated
-const sortedSet_1 = require("./sortedSet");
-// eslint-disable-next-line import/no-deprecated
-class PartialSequenceLengthsSet extends sortedSet_1.SortedSet {
+class PartialSequenceLengthsSet extends SortedSet {
     getKey(item) {
         return item.seq;
     }
@@ -126,7 +122,7 @@ class PartialSequenceLengthsSet extends sortedSet_1.SortedSet {
  * Note: there is some slight complication with clientSeqNumbers resulting from the possibility of different clients
  * concurrently removing the same segment. See the field's documentation for more details.
  */
-class PartialSequenceLengths {
+export class PartialSequenceLengths {
     /**
      * Combine the partial lengths of block's children
      * @param block - an interior node. If `recur` is false, it is assumed that each interior node child of this block
@@ -213,18 +209,18 @@ class PartialSequenceLengths {
             if (child.isLeaf()) {
                 // Leaf segment
                 const segment = child;
-                if (segment.seq !== undefined && (0, mergeTreeNodes_1.seqLTE)(segment.seq, collabWindow.minSeq)) {
+                if (segment.seq !== undefined && seqLTE(segment.seq, collabWindow.minSeq)) {
                     combinedPartialLengths.minLength += segment.cachedLength;
                 }
                 else {
                     PartialSequenceLengths.insertSegment(combinedPartialLengths, segment);
                 }
-                const removalInfo = (0, mergeTreeNodes_1.toRemovalInfo)(segment);
-                const moveInfo = (0, mergeTreeNodes_1.toMoveInfo)(segment);
+                const removalInfo = toRemovalInfo(segment);
+                const moveInfo = toMoveInfo(segment);
                 if ((removalInfo?.removedSeq !== undefined &&
-                    (0, mergeTreeNodes_1.seqLTE)(removalInfo.removedSeq, collabWindow.minSeq)) ||
+                    seqLTE(removalInfo.removedSeq, collabWindow.minSeq)) ||
                     (moveInfo?.movedSeq !== undefined &&
-                        (0, mergeTreeNodes_1.seqLTE)(moveInfo.movedSeq, collabWindow.minSeq))) {
+                        seqLTE(moveInfo.movedSeq, collabWindow.minSeq))) {
                     combinedPartialLengths.minLength -= segment.cachedLength;
                 }
                 else if (removalInfo !== undefined || moveInfo !== undefined) {
@@ -253,7 +249,7 @@ class PartialSequenceLengths {
         return combinedPartialLengths;
     }
     static getOverlapClients(overlapClientIds, seglen) {
-        const bst = new collections_1.RedBlackTree(mergeTreeNodes_1.compareNumbers);
+        const bst = new RedBlackTree(compareNumbers);
         for (const clientId of overlapClientIds) {
             bst.put(clientId, { clientId, seglen });
         }
@@ -380,9 +376,9 @@ class PartialSequenceLengths {
      * `combinedPartialLengths.unsequencedRecords`.
      */
     static insertSegment(combinedPartialLengths, segment, removalInfo, moveInfo) {
-        const removalIsLocal = !!removalInfo && removalInfo.removedSeq === constants_1.UnassignedSequenceNumber;
-        const moveIsLocal = !!moveInfo && moveInfo.movedSeq === constants_1.UnassignedSequenceNumber;
-        const isLocal = segment.seq === constants_1.UnassignedSequenceNumber ||
+        const removalIsLocal = !!removalInfo && removalInfo.removedSeq === UnassignedSequenceNumber;
+        const moveIsLocal = !!moveInfo && moveInfo.movedSeq === UnassignedSequenceNumber;
+        const isLocal = segment.seq === UnassignedSequenceNumber ||
             (!!removalInfo && removalIsLocal && (!moveInfo || moveIsLocal)) ||
             (!!moveInfo && moveIsLocal && (!removalInfo || removalIsLocal));
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -393,7 +389,7 @@ class PartialSequenceLengths {
         let moveClientOverlap;
         let remoteObliteratedLen;
         // it's not possible to have an overlapping obliterate and remove that are both local
-        (0, core_utils_1.assert)((!moveIsLocal && !removalIsLocal) || moveIsLocal !== removalIsLocal, 0x870 /* overlapping local obliterate and remove */);
+        assert((!moveIsLocal && !removalIsLocal) || moveIsLocal !== removalIsLocal, 0x870 /* overlapping local obliterate and remove */);
         const removeHappenedFirst = removalInfo &&
             (!moveInfo ||
                 moveIsLocal ||
@@ -415,7 +411,7 @@ class PartialSequenceLengths {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             seqOrLocalSeq = moveIsLocal ? moveInfo.localMovedSeq : moveInfo.movedSeq;
             if (segment.wasMovedOnInsert) {
-                (0, core_utils_1.assert)(moveInfo.movedSeq !== -1, 0x871 /* wasMovedOnInsert should only be set on acked obliterates */);
+                assert(moveInfo.movedSeq !== -1, 0x871 /* wasMovedOnInsert should only be set on acked obliterates */);
                 segmentLen = 0;
             }
             else {
@@ -585,10 +581,10 @@ class PartialSequenceLengths {
             }
             else {
                 const segment = child;
-                const removalInfo = (0, mergeTreeNodes_1.toRemovalInfo)(segment);
-                const moveInfo = (0, mergeTreeNodes_1.toMoveInfo)(segment);
-                const removalIsLocal = !!removalInfo && removalInfo.removedSeq === constants_1.UnassignedSequenceNumber;
-                const moveIsLocal = !!moveInfo && moveInfo.movedSeq === constants_1.UnassignedSequenceNumber;
+                const removalInfo = toRemovalInfo(segment);
+                const moveInfo = toMoveInfo(segment);
+                const removalIsLocal = !!removalInfo && removalInfo.removedSeq === UnassignedSequenceNumber;
+                const moveIsLocal = !!moveInfo && moveInfo.movedSeq === UnassignedSequenceNumber;
                 const removeHappenedFirst = removalInfo &&
                     (!moveInfo ||
                         moveIsLocal ||
@@ -622,13 +618,13 @@ class PartialSequenceLengths {
                         remoteObliteratedLen -= segment.cachedLength;
                     }
                     else if (segment.wasMovedOnInsert &&
-                        segment.seq !== constants_1.UnassignedSequenceNumber &&
+                        segment.seq !== UnassignedSequenceNumber &&
                         segment.seq !== undefined &&
                         moveInfo.movedSeq > segment.seq) {
                         remoteObliteratedLen += segment.cachedLength;
                         seqSeglen -= segment.cachedLength;
                     }
-                    else if (segment.seq !== constants_1.UnassignedSequenceNumber) {
+                    else if (segment.seq !== UnassignedSequenceNumber) {
                         seqSeglen -= segment.cachedLength;
                     }
                 }
@@ -676,7 +672,7 @@ class PartialSequenceLengths {
             }
         }
         else {
-            (0, core_utils_1.assert)(this.unsequencedRecords !== undefined, 0x39f /* Local getPartialLength invoked without computing local partials. */);
+            assert(this.unsequencedRecords !== undefined, 0x39f /* Local getPartialLength invoked without computing local partials. */);
             const unsequencedPartialLengths = this.unsequencedRecords.partialLengths;
             // Local segments at or before localSeq should also be included
             const local = unsequencedPartialLengths.latestLeq(localSeq);
@@ -805,7 +801,6 @@ class PartialSequenceLengths {
         return cliSeqs && cliSeqs.size > 0 ? cliSeqs.size - 1 : -1;
     }
 }
-exports.PartialSequenceLengths = PartialSequenceLengths;
 PartialSequenceLengths.options = {
     zamboni: true,
 };
@@ -821,14 +816,14 @@ function verifyPartialLengths(partialSeqLengths, partialLengths, clientPartials)
         // Count total number of partial length entries
         count++;
         // Sequence number should be larger or equal to minseq
-        (0, core_utils_1.assert)(partialSeqLengths.minSeq <= partialLength.seq, 0x054 /* "Sequence number less than minSeq!" */);
+        assert(partialSeqLengths.minSeq <= partialLength.seq, 0x054 /* "Sequence number less than minSeq!" */);
         // Sequence number should be sorted
-        (0, core_utils_1.assert)(lastSeqNum < partialLength.seq, 0x055 /* "Sequence number is not sorted!" */);
+        assert(lastSeqNum < partialLength.seq, 0x055 /* "Sequence number is not sorted!" */);
         lastSeqNum = partialLength.seq;
         // Len is a accumulation of all the seglen adjustments
         accumSegLen += partialLength.seglen;
         if (accumSegLen !== partialLength.len) {
-            (0, core_utils_1.assert)(false, 0x056 /* "Unexpected total for accumulation of all seglen adjustments!" */);
+            assert(false, 0x056 /* "Unexpected total for accumulation of all seglen adjustments!" */);
         }
         if (clientPartials) {
             // Client partials used to track local edits so we can account for them some refSeq.
@@ -845,19 +840,19 @@ function verifyPartialLengths(partialSeqLengths, partialLengths, clientPartials)
         else {
             // Len adjustment should not make length negative
             if (partialSeqLengths["minLength"] + partialLength.len < 0) {
-                (0, core_utils_1.assert)(false, 0x057 /* "Negative length after length adjustment!" */);
+                assert(false, 0x057 /* "Negative length after length adjustment!" */);
             }
         }
         if (partialLength.overlapRemoveClients) {
             // Only the flat partialLengths can have overlapRemoveClients, the per client view shouldn't
-            (0, core_utils_1.assert)(!clientPartials, 0x058 /* "Both overlapRemoveClients and clientPartials are set!" */);
+            assert(!clientPartials, 0x058 /* "Both overlapRemoveClients and clientPartials are set!" */);
             // Each overlap client counts as one, but the first remove to sequence was already counted.
             // (this aligns with the logic to omit the removing client in `addClientSeqNumberFromPartial`)
             count += partialLength.overlapRemoveClients.size() - 1;
         }
         if (partialLength.overlapObliterateClients) {
             // Only the flat partialLengths can have overlapObliterateClients, the per client view shouldn't
-            (0, core_utils_1.assert)(!clientPartials, 0x872 /* Both overlapObliterateClients and clientPartials are set! */);
+            assert(!clientPartials, 0x872 /* Both overlapObliterateClients and clientPartials are set! */);
             // Each overlap client counts as one, but the first move to sequence was already counted.
             // (this aligns with the logic to omit the moving client in `addClientSeqNumberFromPartial`)
             count += partialLength.overlapObliterateClients.size() - 1;
@@ -865,7 +860,7 @@ function verifyPartialLengths(partialSeqLengths, partialLengths, clientPartials)
     }
     return count;
 }
-function verifyExpected(mergeTree, node, refSeq, clientId, localSeq) {
+export function verifyExpected(mergeTree, node, refSeq, clientId, localSeq) {
     if ((!mergeTree.collabWindow.collaborating || mergeTree.collabWindow.clientId === clientId) &&
         (node.isLeaf() || localSeq === undefined)) {
         return;
@@ -890,8 +885,7 @@ function verifyExpected(mergeTree, node, refSeq, clientId, localSeq) {
         throw new Error(`expected partial length of ${expected} but found ${partialLen}. refSeq: ${refSeq}, clientId: ${clientId}`);
     }
 }
-exports.verifyExpected = verifyExpected;
-function verify(partialSeqLengths) {
+export function verify(partialSeqLengths) {
     if (partialSeqLengths["clientSeqNumbers"]) {
         for (const cliSeq of partialSeqLengths["clientSeqNumbers"]) {
             if (cliSeq) {
@@ -899,15 +893,14 @@ function verify(partialSeqLengths) {
             }
         }
         // If we have client view, we should have the flat view
-        (0, core_utils_1.assert)(!!partialSeqLengths["partialLengths"], 0x059 /* "Client view exists but flat view does not!" */);
+        assert(!!partialSeqLengths["partialLengths"], 0x059 /* "Client view exists but flat view does not!" */);
         verifyPartialLengths(partialSeqLengths, partialSeqLengths["partialLengths"], false);
     }
     else {
         // If we don't have a client view, we shouldn't have the flat view either
-        (0, core_utils_1.assert)(!partialSeqLengths["partialLengths"], 0x05b /* "Flat view exists but client view does not!" */);
+        assert(!partialSeqLengths["partialLengths"], 0x05b /* "Flat view exists but client view does not!" */);
     }
 }
-exports.verify = verify;
 /* eslint-enable @typescript-eslint/dot-notation */
 /**
  * Clones an `overlapRemoveClients` red-black tree.
@@ -916,7 +909,7 @@ function cloneOverlapRemoveClients(oldTree) {
     if (!oldTree) {
         return undefined;
     }
-    const newTree = new collections_1.RedBlackTree(mergeTreeNodes_1.compareNumbers);
+    const newTree = new RedBlackTree(compareNumbers);
     oldTree.map((bProp) => {
         newTree.put(bProp.data.clientId, { ...bProp.data });
         return true;
@@ -930,7 +923,7 @@ function cloneOverlapRemoveClients(oldTree) {
  *
  * Combination is performed additively on `seglen` on a per-client basis.
  */
-function combineOverlapClients(a, b) {
+export function combineOverlapClients(a, b) {
     function combine(treeA, treeB) {
         if (treeA) {
             if (treeB) {
@@ -959,7 +952,6 @@ function combineOverlapClients(a, b) {
         a.overlapObliterateClients = overlapObliterateClients;
     }
 }
-exports.combineOverlapClients = combineOverlapClients;
 /**
  * Given a number of seq-sorted `partialLength` lists, merges them into a combined seq-sorted `partialLength`
  * list. This merge includes coalescing `PartialSequenceLength` entries at the same seq.
@@ -1037,4 +1029,4 @@ function insertIntoList(list, index, elem) {
         list.push(elem);
     }
 }
-//# sourceMappingURL=partialLengths.js.map
+//# sourceMappingURL=partialLengths.mjs.map