@fluid-experimental/tree 0.58.2002 → 0.59.1000

package/dist/NodeIdUtilities.js

@@ -0,0 +1,60 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeId = exports.getNodeIdContext = exports.sequencedIdNormalizer = exports.scopeIdNormalizer = void 0;
+const Common_1 = require("./Common");
+const id_compressor_1 = require("./id-compressor");
+/**
+ * Create a {@link ContextualizedNodeIdNormalizer} that uses either the given session ID to normalize IDs
+ * to session space. If no ID is given, it will use the local session ID belonging to the normalizer.
+ */
+function scopeIdNormalizer(idNormalizer, sessionId) {
+    return {
+        normalizeToOpSpace: (id) => idNormalizer.normalizeToOpSpace(id),
+        normalizeToSessionSpace: (id) => idNormalizer.normalizeToSessionSpace(id, sessionId !== null && sessionId !== void 0 ? sessionId : idNormalizer.localSessionId),
+    };
+}
+exports.scopeIdNormalizer = scopeIdNormalizer;
+/**
+ * Create a {@link ContextualizedNodeIdNormalizer} that uses the local session ID belonging to the normalizer
+ * to normalize IDs to session space. These IDs are expected to be sequenced, and will fail to normalize if
+ * they are not.
+ */
+function sequencedIdNormalizer(idNormalizer) {
+    return {
+        normalizeToOpSpace: (id) => {
+            const normalized = idNormalizer.normalizeToOpSpace(id);
+            Common_1.assert(id_compressor_1.isFinalId(normalized));
+            return normalized;
+        },
+        normalizeToSessionSpace: (id) => {
+            const normalized = idNormalizer.normalizeToSessionSpace(id, idNormalizer.localSessionId);
+            Common_1.assert(id_compressor_1.isFinalId(normalized));
+            return normalized;
+        },
+    };
+}
+exports.sequencedIdNormalizer = sequencedIdNormalizer;
+function getNodeIdContext(compressor) {
+    return {
+        generateNodeId: (override) => compressor.generateCompressedId(override),
+        convertToNodeId: (id) => compressor.recompress(id),
+        tryConvertToNodeId: (id) => compressor.tryRecompress(id),
+        convertToStableNodeId: (id) => compressor.decompress(id),
+        tryConvertToStableNodeId: (id) => compressor.tryDecompress(id),
+        normalizeToOpSpace: (id) => compressor.normalizeToOpSpace(id),
+        normalizeToSessionSpace: (id, sessionId) => compressor.normalizeToSessionSpace(id, sessionId),
+        localSessionId: compressor.localSessionId,
+    };
+}
+exports.getNodeIdContext = getNodeIdContext;
+/** Accepts either a node or a node's identifier, and returns the identifier */
+function getNodeId(node) {
+    var _a;
+    return (_a = node.identifier) !== null && _a !== void 0 ? _a : node;
+}
+exports.getNodeId = getNodeId;
+//# sourceMappingURL=NodeIdUtilities.js.map

package/dist/NodeIdUtilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeIdUtilities.js","sourceRoot":"","sources":["../src/NodeIdUtilities.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,qCAAkC;AAClC,mDAA0D;AA+F1D;;;GAGG;AACH,SAAgB,iBAAiB,CAChC,YAAmC,EACnC,SAAqB;IAErB,OAAO;QACN,kBAAkB,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,YAAY,CAAC,kBAAkB,CAAC,EAAE,CAAC;QAC/D,uBAAuB,EAAE,CAAC,EAAE,EAAE,EAAE,CAC/B,YAAY,CAAC,uBAAuB,CAAC,EAAE,EAAE,SAAS,aAAT,SAAS,cAAT,SAAS,GAAI,YAAY,CAAC,cAAc,CAAC;KACnF,CAAC;AACH,CAAC;AATD,8CASC;AAED;;;;GAIG;AACH,SAAgB,qBAAqB,CACpC,YAAmC;IAEnC,OAAO;QACN,kBAAkB,EAAE,CAAC,EAAE,EAAE,EAAE;YAC1B,MAAM,UAAU,GAAG,YAAY,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAC;YACvD,eAAM,CAAC,yBAAS,CAAC,UAAU,CAAC,CAAC,CAAC;YAC9B,OAAO,UAAU,CAAC;QACnB,CAAC;QACD,uBAAuB,EAAE,CAAC,EAAE,EAAE,EAAE;YAC/B,MAAM,UAAU,GAAG,YAAY,CAAC,uBAAuB,CAAC,EAAE,EAAE,YAAY,CAAC,cAAc,CAAC,CAAC;YACzF,eAAM,CAAC,yBAAS,CAAC,UAAU,CAAC,CAAC,CAAC;YAC9B,OAAO,UAAU,CAAC;QACnB,CAAC;KACD,CAAC;AACH,CAAC;AAfD,sDAeC;AAED,SAAgB,gBAAgB,CAAC,UAAwB;IACxD,OAAO;QACN,cAAc,EAAE,CAAC,QAAiB,EAAE,EAAE,CAAC,UAAU,CAAC,oBAAoB,CAAC,QAAQ,CAAW;QAC1F,eAAe,EAAE,CAAC,EAAgB,EAAE,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAW;QAC1E,kBAAkB,EAAE,CAAC,EAAgB,EAAE,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE,CAAuB;QAC5F,qBAAqB,EAAE,CAAC,EAAU,EAAE,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAiB;QAChF,wBAAwB,EAAE,CAAC,EAAU,EAAE,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE,CAAiB;QACtF,kBAAkB,EAAE,CAAC,EAAU,EAAE,EAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC,EAAE,CAAkB;QACtF,uBAAuB,EAAE,CAAC,EAAiB,EAAE,SAAoB,EAAE,EAAE,CACpE,UAAU,CAAC,uBAAuB,CAAC,EAAE,EAAE,SAAS,CAAW;QAC5D,cAAc,EAAE,UAAU,CAAC,cAAc;KACzC,CAAC;AACH,CAAC;AAZD,4CAYC;AAED,+EAA+E;AAC/E,SAAgB,SAAS,CAA8B,IAAyB;;IAC/E,aAAQ,IAAsB,CAAC,UAAU,mCAAK,IAAY,CAAC;AAC5D,CAAC;AAFD,8BAEC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from './Common';\nimport { IdCompressor, isFinalId } from './id-compressor';\nimport { FinalNodeId, NodeId, OpSpaceNodeId, SessionId, StableNodeId } from './Identifiers';\nimport { NodeData } from './persisted-types';\n\n/**\n * An object which can generate node IDs and convert node IDs between compressed and stable variants\n * @public\n */\nexport interface NodeIdContext extends NodeIdGenerator, NodeIdConverter {}\n\n/**\n * An object which can generate node IDs\n * @public\n */\nexport interface NodeIdGenerator {\n\t/**\n\t * Generates a node identifier.\n\t * The returned IDs may be used as the identifier of a node in the SharedTree.\n\t * `NodeId`s are *always* unique and stable within the scope of the tree and session that generated them. They are *not* unique within\n\t * a Fluid container, and *cannot* be compared across instances of a SharedTree. They are *not* stable across sessions/lifetimes of a\n\t * SharedTree, and *cannot* be persisted (e.g. stored in payloads, uploaded in blobs, etc.). If stable persistence is needed,\n\t * NodeIdConverter.convertToStableNodeId may be used to return a corresponding UUID that is globally unique and stable.\n\t * @param override - if supplied, calls to `convertToStableNodeId` using the returned node ID will return the override instead of\n\t * the UUID. Calls to `generateNodeId` with the same override always return the same ID. Performance note: passing an override string\n\t * incurs a storage cost that is significantly higher that a node ID without one, and should be avoided if possible.\n\t */\n\tgenerateNodeId(override?: string): NodeId;\n}\n\n/**\n * An object which can convert node IDs between compressed and stable variants\n * @public\n */\nexport interface NodeIdConverter {\n\t/**\n\t * Given a NodeId, returns the corresponding stable ID or throws if the supplied node ID was not generated with this tree (`NodeId`s\n\t * may not be used across SharedTree instances, see `generateNodeId` for more).\n\t * The returned value will be a UUID, unless the creation of `id` used an override string (see `generateNodeId` for more).\n\t * The result is safe to persist and re-use across `SharedTree` instances, unlike `NodeId`.\n\t */\n\tconvertToStableNodeId(id: NodeId): StableNodeId;\n\n\t/**\n\t * Given a NodeId, attempt to return the corresponding stable ID.\n\t * The returned value will be a UUID, unless the creation of `id` used an override string (see `generateNodeId` for more).\n\t * The returned stable ID is undefined if `id` was never created with this SharedTree. If a stable ID is returned, this does not imply\n\t * that there is a node with `id` in the current revision of the tree, only that `id` was at some point generated by some instance of\n\t * this tree.\n\t */\n\ttryConvertToStableNodeId(id: NodeId): StableNodeId | undefined;\n\n\t/**\n\t * Given a stable ID, return the corresponding NodeId or throws if the supplied stable ID was never generated with this tree, either\n\t * as a UUID corresponding to a `NodeId` or as an override passed to `generateNodeId`.\n\t * If a stable ID is returned, this does not imply that there is a node with `id` in the current revision of the tree, only that\n\t * `id` was at some point generated by an instance of this SharedTree.\n\t */\n\tconvertToNodeId(id: StableNodeId): NodeId;\n\n\t/**\n\t * Given a stable ID, return the corresponding NodeId or return undefined if the supplied stable ID was never generated with this tree,\n\t * either as a UUID corresponding to a `NodeId` or as an override passed to `generateNodeId`.\n\t * If a stable ID is returned, this does not imply that there is a node with `id` in the current revision of the tree, only that\n\t * `id` was at some point generated by an instance of this SharedTree.\n\t */\n\ttryConvertToNodeId(id: StableNodeId): NodeId | undefined;\n}\n\n/**\n * An object which can normalize node IDs. See docs on {@link IdCompressor} for semantics of normalization.\n */\nexport interface NodeIdNormalizer<TId extends OpSpaceNodeId> {\n\tlocalSessionId: SessionId;\n\t/**\n\t * Normalizes the given ID to op space\n\t */\n\tnormalizeToOpSpace(id: NodeId): TId;\n\t/**\n\t * Normalizes the given ID to session space\n\t */\n\tnormalizeToSessionSpace(id: TId, sessionId: SessionId): NodeId;\n}\n\n/**\n * An object which can normalize node IDs. It is contextualized to a known session context, and therefore\n * can normalize IDs into session space without requiring any additional information.\n */\nexport interface ContextualizedNodeIdNormalizer<TId extends OpSpaceNodeId>\n\textends Omit<NodeIdNormalizer<TId>, 'localSessionId' | 'normalizeToSessionSpace'> {\n\t/**\n\t * Normalizes the given ID to session space\n\t */\n\tnormalizeToSessionSpace(id: TId): NodeId;\n}\n\n/**\n * Create a {@link ContextualizedNodeIdNormalizer} that uses either the given session ID to normalize IDs\n * to session space. If no ID is given, it will use the local session ID belonging to the normalizer.\n */\nexport function scopeIdNormalizer<TId extends OpSpaceNodeId>(\n\tidNormalizer: NodeIdNormalizer<TId>,\n\tsessionId?: SessionId\n): ContextualizedNodeIdNormalizer<TId> {\n\treturn {\n\t\tnormalizeToOpSpace: (id) => idNormalizer.normalizeToOpSpace(id),\n\t\tnormalizeToSessionSpace: (id) =>\n\t\t\tidNormalizer.normalizeToSessionSpace(id, sessionId ?? idNormalizer.localSessionId),\n\t};\n}\n\n/**\n * Create a {@link ContextualizedNodeIdNormalizer} that uses the local session ID belonging to the normalizer\n * to normalize IDs to session space. These IDs are expected to be sequenced, and will fail to normalize if\n * they are not.\n */\nexport function sequencedIdNormalizer<TId extends OpSpaceNodeId>(\n\tidNormalizer: NodeIdNormalizer<TId>\n): ContextualizedNodeIdNormalizer<FinalNodeId & TId> {\n\treturn {\n\t\tnormalizeToOpSpace: (id) => {\n\t\t\tconst normalized = idNormalizer.normalizeToOpSpace(id);\n\t\t\tassert(isFinalId(normalized));\n\t\t\treturn normalized;\n\t\t},\n\t\tnormalizeToSessionSpace: (id) => {\n\t\t\tconst normalized = idNormalizer.normalizeToSessionSpace(id, idNormalizer.localSessionId);\n\t\t\tassert(isFinalId(normalized));\n\t\t\treturn normalized;\n\t\t},\n\t};\n}\n\nexport function getNodeIdContext(compressor: IdCompressor): NodeIdContext & NodeIdNormalizer<OpSpaceNodeId> {\n\treturn {\n\t\tgenerateNodeId: (override?: string) => compressor.generateCompressedId(override) as NodeId,\n\t\tconvertToNodeId: (id: StableNodeId) => compressor.recompress(id) as NodeId,\n\t\ttryConvertToNodeId: (id: StableNodeId) => compressor.tryRecompress(id) as NodeId | undefined,\n\t\tconvertToStableNodeId: (id: NodeId) => compressor.decompress(id) as StableNodeId,\n\t\ttryConvertToStableNodeId: (id: NodeId) => compressor.tryDecompress(id) as StableNodeId,\n\t\tnormalizeToOpSpace: (id: NodeId) => compressor.normalizeToOpSpace(id) as OpSpaceNodeId,\n\t\tnormalizeToSessionSpace: (id: OpSpaceNodeId, sessionId: SessionId) =>\n\t\t\tcompressor.normalizeToSessionSpace(id, sessionId) as NodeId,\n\t\tlocalSessionId: compressor.localSessionId,\n\t};\n}\n\n/** Accepts either a node or a node's identifier, and returns the identifier */\nexport function getNodeId<TId extends number | string>(node: TId | NodeData<TId>): TId {\n\treturn (node as NodeData<TId>).identifier ?? (node as TId);\n}\n"]}

package/dist/PayloadUtilities.d.ts

@@ -0,0 +1,42 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Payload } from './persisted-types';
+/**
+ * @returns true if two `Payloads` are identical.
+ * May return false for equivalent payloads encoded differently.
+ *
+ * Object field order and object identity are not considered significant, and are ignored by this function.
+ * (This is because they may not be preserved through roundtrip).
+ *
+ * For other information which Fluid would lose on serialization round trip,
+ * behavior is unspecified other than this this function is reflective (all payloads are equal to themselves)
+ * and commutative (argument order does not matter).
+ *
+ * This means that any Payload is equal to itself and a deep clone of itself.
+ *
+ * Payloads might not be equal to a version of themselves that has been serialized then deserialized.
+ * If they are serialized then deserialized again, the two deserialized objects will compare equal,
+ * however the serialized strings may be unequal (due to field order for objects being unspecified).
+ *
+ * Fluid will cause lossy operations due to use of JSON.stringify().
+ * This includes:
+ * - Loss of object identity
+ * - Loss of field order (may be ordered arbitrarily)
+ * - -0 becomes +0
+ * - NaN, Infinity, -Infinity all become null
+ * - custom toJSON functions may cause arbitrary behavior
+ * - functions become undefined or null
+ * - non enumerable properties (including prototype) are lost
+ * - more (this is not a complete list)
+ *
+ * Inputs must not contain cyclic references other than fields set to their immediate parent (for the JavaScript feature detection pattern).
+ *
+ * IFluidHandle instances (detected via JavaScript feature detection pattern) are only compared by absolutePath.
+ *
+ * TODO:#54095: Is there a better way to do this comparison?
+ * @public
+ */
+export declare function comparePayloads(a: Payload, b: Payload): boolean;
+//# sourceMappingURL=PayloadUtilities.d.ts.map

package/dist/PayloadUtilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PayloadUtilities.d.ts","sourceRoot":"","sources":["../src/PayloadUtilities.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CA+E/D"}

package/dist/PayloadUtilities.js

@@ -0,0 +1,114 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.comparePayloads = void 0;
+const Common_1 = require("./Common");
+/**
+ * @returns true if two `Payloads` are identical.
+ * May return false for equivalent payloads encoded differently.
+ *
+ * Object field order and object identity are not considered significant, and are ignored by this function.
+ * (This is because they may not be preserved through roundtrip).
+ *
+ * For other information which Fluid would lose on serialization round trip,
+ * behavior is unspecified other than this this function is reflective (all payloads are equal to themselves)
+ * and commutative (argument order does not matter).
+ *
+ * This means that any Payload is equal to itself and a deep clone of itself.
+ *
+ * Payloads might not be equal to a version of themselves that has been serialized then deserialized.
+ * If they are serialized then deserialized again, the two deserialized objects will compare equal,
+ * however the serialized strings may be unequal (due to field order for objects being unspecified).
+ *
+ * Fluid will cause lossy operations due to use of JSON.stringify().
+ * This includes:
+ * - Loss of object identity
+ * - Loss of field order (may be ordered arbitrarily)
+ * - -0 becomes +0
+ * - NaN, Infinity, -Infinity all become null
+ * - custom toJSON functions may cause arbitrary behavior
+ * - functions become undefined or null
+ * - non enumerable properties (including prototype) are lost
+ * - more (this is not a complete list)
+ *
+ * Inputs must not contain cyclic references other than fields set to their immediate parent (for the JavaScript feature detection pattern).
+ *
+ * IFluidHandle instances (detected via JavaScript feature detection pattern) are only compared by absolutePath.
+ *
+ * TODO:#54095: Is there a better way to do this comparison?
+ * @public
+ */
+function comparePayloads(a, b) {
+    // === is not reflective because of how NaN is handled, so use Object.is instead.
+    // This treats -0 and +0 as different.
+    // Since -0 is not preserved in serialization round trips,
+    // it can be handed in any way that is reflective and commutative, so this is fine.
+    if (Object.is(a, b)) {
+        return true;
+    }
+    // Primitives which are equal would have early returned above, so now if the values are not both objects, they are unequal.
+    if (typeof a !== 'object' || typeof b !== 'object') {
+        return false;
+    }
+    // null is of type object, and needs to be treated as distinct from the empty object.
+    // Handling it early also avoids type errors trying to access its keys.
+    // Rationale: 'undefined' payloads are reserved for future use (see 'SetValue' interface).
+    if (a === null || b === null) {
+        return false;
+    }
+    // Special case IFluidHandles, comparing them only by their absolutePath
+    // Detect them using JavaScript feature detection pattern: they have a `IFluidHandle` field that is set to the parent object.
+    {
+        const aHandle = a;
+        const bHandle = b;
+        if (aHandle.IFluidHandle === a) {
+            if (bHandle.IFluidHandle !== b) {
+                return false;
+            }
+            return a.absolutePath === b.absolutePath;
+        }
+    }
+    // Fluid Serialization (like Json) only keeps enumerable properties, so we can ignore non-enumerable ones.
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    // make sure objects with numeric keys (or no keys) compare unequal to arrays.
+    if (a instanceof Array !== b instanceof Array) {
+        return false;
+    }
+    // Fluid Serialization (like Json) orders object fields arbitrarily, so reordering fields is not considered considered a change.
+    // Therefor the keys arrays must be sorted here.
+    if (!(a instanceof Array)) {
+        aKeys.sort();
+        bKeys.sort();
+    }
+    // First check keys are equal.
+    // This will often early exit, and thus is worth doing as a separate pass than recursive check.
+    if (!Common_1.compareArrays(aKeys, bKeys)) {
+        return false;
+    }
+    for (let i = 0; i < aKeys.length; i++) {
+        const aItem = a[aKeys[i]];
+        const bItem = b[bKeys[i]];
+        // The JavaScript feature detection pattern, used for IFluidHandle, uses a field that is set to the parent object.
+        // Detect this pattern and special case it to avoid infinite recursion.
+        const aSelf = Object.is(aItem, a);
+        const bSelf = Object.is(bItem, b);
+        if (aSelf !== bSelf) {
+            return false;
+        }
+        if (!aSelf) {
+            if (!comparePayloads(aItem, bItem)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+exports.comparePayloads = comparePayloads;
+//# sourceMappingURL=PayloadUtilities.js.map

package/dist/PayloadUtilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PayloadUtilities.js","sourceRoot":"","sources":["../src/PayloadUtilities.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAGH,qCAAyC;AAGzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,SAAgB,eAAe,CAAC,CAAU,EAAE,CAAU;IACrD,iFAAiF;IACjF,sCAAsC;IACtC,0DAA0D;IAC1D,mFAAmF;IACnF,IAAI,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;QACpB,OAAO,IAAI,CAAC;KACZ;IAED,2HAA2H;IAC3H,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE;QACnD,OAAO,KAAK,CAAC;KACb;IAED,qFAAqF;IACrF,uEAAuE;IACvE,0FAA0F;IAC1F,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,IAAI,EAAE;QAC7B,OAAO,KAAK,CAAC;KACb;IAED,wEAAwE;IACxE,6HAA6H;IAC7H;QACC,MAAM,OAAO,GAAG,CAAiB,CAAC;QAClC,MAAM,OAAO,GAAG,CAAiB,CAAC;QAClC,IAAI,OAAO,CAAC,YAAY,KAAK,CAAC,EAAE;YAC/B,IAAI,OAAO,CAAC,YAAY,KAAK,CAAC,EAAE;gBAC/B,OAAO,KAAK,CAAC;aACb;YACD,OAAO,CAAC,CAAC,YAAY,KAAK,CAAC,CAAC,YAAY,CAAC;SACzC;KACD;IAED,0GAA0G;IAC1G,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC7B,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAE7B,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,EAAE;QAClC,OAAO,KAAK,CAAC;KACb;IAED,8EAA8E;IAC9E,IAAI,CAAC,YAAY,KAAK,KAAK,CAAC,YAAY,KAAK,EAAE;QAC9C,OAAO,KAAK,CAAC;KACb;IAED,gIAAgI;IAChI,gDAAgD;IAChD,IAAI,CAAC,CAAC,CAAC,YAAY,KAAK,CAAC,EAAE;QAC1B,KAAK,CAAC,IAAI,EAAE,CAAC;QACb,KAAK,CAAC,IAAI,EAAE,CAAC;KACb;IAED,8BAA8B;IAC9B,+FAA+F;IAC/F,IAAI,CAAC,sBAAa,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE;QACjC,OAAO,KAAK,CAAC;KACb;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACtC,MAAM,KAAK,GAAY,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACnC,MAAM,KAAK,GAAY,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAEnC,kHAAkH;QAClH,uEAAuE;QACvE,MAAM,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAClC,MAAM,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAClC,IAAI,KAAK,KAAK,KAAK,EAAE;YACpB,OAAO,KAAK,CAAC;SACb;QACD,IAAI,CAAC,KAAK,EAAE;YACX,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE;gBACnC,OAAO,KAAK,CAAC;aACb;SACD;KACD;IAED,OAAO,IAAI,CAAC;AACb,CAAC;AA/ED,0CA+EC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { IFluidHandle } from '@fluidframework/core-interfaces';\nimport { compareArrays } from './Common';\nimport { Payload } from './persisted-types';\n\n/**\n * @returns true if two `Payloads` are identical.\n * May return false for equivalent payloads encoded differently.\n *\n * Object field order and object identity are not considered significant, and are ignored by this function.\n * (This is because they may not be preserved through roundtrip).\n *\n * For other information which Fluid would lose on serialization round trip,\n * behavior is unspecified other than this this function is reflective (all payloads are equal to themselves)\n * and commutative (argument order does not matter).\n *\n * This means that any Payload is equal to itself and a deep clone of itself.\n *\n * Payloads might not be equal to a version of themselves that has been serialized then deserialized.\n * If they are serialized then deserialized again, the two deserialized objects will compare equal,\n * however the serialized strings may be unequal (due to field order for objects being unspecified).\n *\n * Fluid will cause lossy operations due to use of JSON.stringify().\n * This includes:\n * - Loss of object identity\n * - Loss of field order (may be ordered arbitrarily)\n * - -0 becomes +0\n * - NaN, Infinity, -Infinity all become null\n * - custom toJSON functions may cause arbitrary behavior\n * - functions become undefined or null\n * - non enumerable properties (including prototype) are lost\n * - more (this is not a complete list)\n *\n * Inputs must not contain cyclic references other than fields set to their immediate parent (for the JavaScript feature detection pattern).\n *\n * IFluidHandle instances (detected via JavaScript feature detection pattern) are only compared by absolutePath.\n *\n * TODO:#54095: Is there a better way to do this comparison?\n * @public\n */\nexport function comparePayloads(a: Payload, b: Payload): boolean {\n\t// === is not reflective because of how NaN is handled, so use Object.is instead.\n\t// This treats -0 and +0 as different.\n\t// Since -0 is not preserved in serialization round trips,\n\t// it can be handed in any way that is reflective and commutative, so this is fine.\n\tif (Object.is(a, b)) {\n\t\treturn true;\n\t}\n\n\t// Primitives which are equal would have early returned above, so now if the values are not both objects, they are unequal.\n\tif (typeof a !== 'object' || typeof b !== 'object') {\n\t\treturn false;\n\t}\n\n\t// null is of type object, and needs to be treated as distinct from the empty object.\n\t// Handling it early also avoids type errors trying to access its keys.\n\t// Rationale: 'undefined' payloads are reserved for future use (see 'SetValue' interface).\n\tif (a === null || b === null) {\n\t\treturn false;\n\t}\n\n\t// Special case IFluidHandles, comparing them only by their absolutePath\n\t// Detect them using JavaScript feature detection pattern: they have a `IFluidHandle` field that is set to the parent object.\n\t{\n\t\tconst aHandle = a as IFluidHandle;\n\t\tconst bHandle = b as IFluidHandle;\n\t\tif (aHandle.IFluidHandle === a) {\n\t\t\tif (bHandle.IFluidHandle !== b) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\treturn a.absolutePath === b.absolutePath;\n\t\t}\n\t}\n\n\t// Fluid Serialization (like Json) only keeps enumerable properties, so we can ignore non-enumerable ones.\n\tconst aKeys = Object.keys(a);\n\tconst bKeys = Object.keys(b);\n\n\tif (aKeys.length !== bKeys.length) {\n\t\treturn false;\n\t}\n\n\t// make sure objects with numeric keys (or no keys) compare unequal to arrays.\n\tif (a instanceof Array !== b instanceof Array) {\n\t\treturn false;\n\t}\n\n\t// Fluid Serialization (like Json) orders object fields arbitrarily, so reordering fields is not considered considered a change.\n\t// Therefor the keys arrays must be sorted here.\n\tif (!(a instanceof Array)) {\n\t\taKeys.sort();\n\t\tbKeys.sort();\n\t}\n\n\t// First check keys are equal.\n\t// This will often early exit, and thus is worth doing as a separate pass than recursive check.\n\tif (!compareArrays(aKeys, bKeys)) {\n\t\treturn false;\n\t}\n\n\tfor (let i = 0; i < aKeys.length; i++) {\n\t\tconst aItem: Payload = a[aKeys[i]];\n\t\tconst bItem: Payload = b[bKeys[i]];\n\n\t\t// The JavaScript feature detection pattern, used for IFluidHandle, uses a field that is set to the parent object.\n\t\t// Detect this pattern and special case it to avoid infinite recursion.\n\t\tconst aSelf = Object.is(aItem, a);\n\t\tconst bSelf = Object.is(bItem, b);\n\t\tif (aSelf !== bSelf) {\n\t\t\treturn false;\n\t\t}\n\t\tif (!aSelf) {\n\t\t\tif (!comparePayloads(aItem, bItem)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn true;\n}\n"]}

package/dist/ReconciliationPath.d.ts

@@ -2,14 +2,17 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { Snapshot } from './Snapshot';
+import { ChangeInternal } from './persisted-types';
+import { TransactionView } from './RevisionView';
+import { TreeView } from './TreeView';
 /**
- * The path of edits from the snapshot where a change was meant to have been applied to the snapshot where the edit that contains the change
- * is actually applied.
+ * The path of edits from the revision view where a change was meant to have been applied to the view where the edit that contains the
+ * change is actually applied.
  * The path only contains edits that were successfully applied.
  * This path is always empty for a change that has no concurrent edits.
+ * @public
  */
-export interface ReconciliationPath<TChange> {
+export interface ReconciliationPath {
     /**
      * The number of edits in the path.
      */
@@ -18,20 +21,21 @@ export interface ReconciliationPath<TChange> {
      * Allows access to edit information.
      * @returns Reconciliation information for the edit at the given `index`.
      */
-    readonly [index: number]: ReconciliationEdit<TChange>;
+    readonly [index: number]: ReconciliationEdit;
 }
 /**
  * An edit in the `ReconciliationPath`.
+ * @public
  */
-export interface ReconciliationEdit<TChange> {
+export interface ReconciliationEdit {
     /**
      * The state before the edit was applied.
      */
-    readonly before: Snapshot;
+    readonly before: TreeView;
     /**
      * The state after the edit was applied.
      */
-    readonly after: Snapshot;
+    readonly after: TreeView;
     /**
      * The number of changes in the edit.
      */
@@ -40,20 +44,21 @@ export interface ReconciliationEdit<TChange> {
      * Allows access to change information.
      * @returns Reconciliation information for the change at the given `index`.
      */
-    readonly [index: number]: ReconciliationChange<TChange>;
+    readonly [index: number]: ReconciliationChange;
 }
 /**
  * A change in the `ReconciliationPath`.
+ * @public
  */
-export interface ReconciliationChange<TChange> {
+export interface ReconciliationChange {
     /**
      * The resolved change that was applied during the edit.
      * Resolved changes are guaranteed to be expressed with valid tree locations instead of anchors that need resolution.
      */
-    readonly resolvedChange: TChange;
+    readonly resolvedChange: ChangeInternal;
     /**
-     * The resulting snapshot state from applying the resolved change.
+     * The resulting view from applying the resolved change.
      */
-    readonly after: Snapshot;
+    readonly after: TransactionView;
 }
 //# sourceMappingURL=ReconciliationPath.d.ts.map

package/dist/ReconciliationPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReconciliationPath.d.ts","sourceRoot":"","sources":["../src/ReconciliationPath.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB,CAAC,OAAO;IAC1C;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAAC,OAAO,CAAC,CAAC;CACtD;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,OAAO;IAC1C;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;CACxD;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB,CAAC,OAAO;IAC5C;;;OAGG;IACH,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;CACzB"}
+{"version":3,"file":"ReconciliationPath.d.ts","sourceRoot":"","sources":["../src/ReconciliationPath.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IAClC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAAC;CAC7C;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IAClC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,oBAAoB,CAAC;CAC/C;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACpC;;;OAGG;IACH,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;IACxC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;CAChC"}

package/dist/ReconciliationPath.js.map

@@ -1 +1 @@
-{"version":3,"file":"ReconciliationPath.js","sourceRoot":"","sources":["../src/ReconciliationPath.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { Snapshot } from './Snapshot';\n\n/**\n * The path of edits from the snapshot where a change was meant to have been applied to the snapshot where the edit that contains the change\n * is actually applied.\n * The path only contains edits that were successfully applied.\n * This path is always empty for a change that has no concurrent edits.\n */\nexport interface ReconciliationPath<TChange> {\n\t/**\n\t * The number of edits in the path.\n\t */\n\treadonly length: number;\n\t/**\n\t * Allows access to edit information.\n\t * @returns Reconciliation information for the edit at the given `index`.\n\t */\n\treadonly [index: number]: ReconciliationEdit<TChange>;\n}\n\n/**\n * An edit in the `ReconciliationPath`.\n */\nexport interface ReconciliationEdit<TChange> {\n\t/**\n\t * The state before the edit was applied.\n\t */\n\treadonly before: Snapshot;\n\t/**\n\t * The state after the edit was applied.\n\t */\n\treadonly after: Snapshot;\n\t/**\n\t * The number of changes in the edit.\n\t */\n\treadonly length: number;\n\t/**\n\t * Allows access to change information.\n\t * @returns Reconciliation information for the change at the given `index`.\n\t */\n\treadonly [index: number]: ReconciliationChange<TChange>;\n}\n\n/**\n * A change in the `ReconciliationPath`.\n */\nexport interface ReconciliationChange<TChange> {\n\t/**\n\t * The resolved change that was applied during the edit.\n\t * Resolved changes are guaranteed to be expressed with valid tree locations instead of anchors that need resolution.\n\t */\n\treadonly resolvedChange: TChange;\n\t/**\n\t * The resulting snapshot state from applying the resolved change.\n\t */\n\treadonly after: Snapshot;\n}\n"]}
+{"version":3,"file":"ReconciliationPath.js","sourceRoot":"","sources":["../src/ReconciliationPath.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { ChangeInternal } from './persisted-types';\nimport { TransactionView } from './RevisionView';\nimport { TreeView } from './TreeView';\n\n/**\n * The path of edits from the revision view where a change was meant to have been applied to the view where the edit that contains the\n * change is actually applied.\n * The path only contains edits that were successfully applied.\n * This path is always empty for a change that has no concurrent edits.\n * @public\n */\nexport interface ReconciliationPath {\n\t/**\n\t * The number of edits in the path.\n\t */\n\treadonly length: number;\n\t/**\n\t * Allows access to edit information.\n\t * @returns Reconciliation information for the edit at the given `index`.\n\t */\n\treadonly [index: number]: ReconciliationEdit;\n}\n\n/**\n * An edit in the `ReconciliationPath`.\n * @public\n */\nexport interface ReconciliationEdit {\n\t/**\n\t * The state before the edit was applied.\n\t */\n\treadonly before: TreeView;\n\t/**\n\t * The state after the edit was applied.\n\t */\n\treadonly after: TreeView;\n\t/**\n\t * The number of changes in the edit.\n\t */\n\treadonly length: number;\n\t/**\n\t * Allows access to change information.\n\t * @returns Reconciliation information for the change at the given `index`.\n\t */\n\treadonly [index: number]: ReconciliationChange;\n}\n\n/**\n * A change in the `ReconciliationPath`.\n * @public\n */\nexport interface ReconciliationChange {\n\t/**\n\t * The resolved change that was applied during the edit.\n\t * Resolved changes are guaranteed to be expressed with valid tree locations instead of anchors that need resolution.\n\t */\n\treadonly resolvedChange: ChangeInternal;\n\t/**\n\t * The resulting view from applying the resolved change.\n\t */\n\treadonly after: TransactionView;\n}\n"]}

package/dist/RevisionValueCache.d.ts

@@ -2,7 +2,15 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { Revision } from './LogViewer';
+/**
+ * A revision corresponds to an index in an `EditLog`.
+ *
+ * It is associated with the output `RevisionView` of applying the edit at the index to the previous revision.
+ * For example:
+ *  - revision 0 corresponds to the initialRevision.
+ *  - revision 1 corresponds to the output of editLog[0] applied to the initialRevision.
+ */
+export declare type Revision = number;
 /**
  * A cache of `TValue`s corresponding to `Revision`s.
  *
@@ -25,9 +33,10 @@ export declare class RevisionValueCache<TValue> {
      */
     private readonly sortedEntries;
     /**
-     * Least recently used cache of evictable entries.
+     * Cache of most recently used evictable entries.
      * Subset of 'sortedValues` eligible for eviction:
      * All entries are also in `sortedValues`, and are removed from `sortedValues` when evicted from this cache.
+     * Evicts least recently used entries.
      */
     private readonly evictableRevisions;
     /**

package/dist/RevisionValueCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RevisionValueCache.d.ts","sourceRoot":"","sources":["../src/RevisionValueCache.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC;;;;;;;;GAQG;AACH,qBAAa,kBAAkB,CAAC,MAAM;IAyBpC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IA5B7B;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgE;IAE9F;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAwB;IAE3D;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuB;;IAGxD;;OAEG;IACH,aAAa,EAAE,MAAM;IACrB;;;OAGG;IACK,oBAAoB,EAAE,QAAQ;IACtC;;OAEG;IACH,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE;IAqBvC;;OAEG;IACI,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAI3D;;;OAGG;IACI,qBAAqB,CAAC,uBAAuB,EAAE,QAAQ,GAAG,IAAI;IAwBrE;;OAEG;IACI,eAAe,CAAC,iBAAiB,EAAE,QAAQ,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,SAAS;IAQpG;;OAEG;IACI,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAKlE;;;;;;OAMG;IACI,UAAU,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAS1D"}
+{"version":3,"file":"RevisionValueCache.d.ts","sourceRoot":"","sources":["../src/RevisionValueCache.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH;;;;;;;GAOG;AACH,oBAAY,QAAQ,GAAG,MAAM,CAAC;AAE9B;;;;;;;;GAQG;AACH,qBAAa,kBAAkB,CAAC,MAAM;IA0BpC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IA7B7B;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgE;IAE9F;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAwB;IAE3D;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuB;;IAGxD;;OAEG;IACH,aAAa,EAAE,MAAM;IACrB;;;OAGG;IACK,oBAAoB,EAAE,QAAQ;IACtC;;OAEG;IACH,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE;IAqBvC;;OAEG;IACI,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAI3D;;;OAGG;IACI,qBAAqB,CAAC,uBAAuB,EAAE,QAAQ,GAAG,IAAI;IAwBrE;;OAEG;IACI,eAAe,CAAC,iBAAiB,EAAE,QAAQ,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,SAAS;IAQpG;;OAEG;IACI,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAKlE;;;;;;OAMG;IACI,UAAU,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAS1D"}

package/dist/RevisionValueCache.js

@@ -11,7 +11,6 @@ exports.RevisionValueCache = void 0;
 const sorted_btree_1 = __importDefault(require("sorted-btree"));
 const lru_cache_1 = __importDefault(require("lru-cache"));
 const Common_1 = require("./Common");
-const SnapshotUtilities_1 = require("./SnapshotUtilities");
 /**
  * A cache of `TValue`s corresponding to `Revision`s.
  *
@@ -42,7 +41,7 @@ class RevisionValueCache {
          * This is sorted to allow efficient access to the nearest preceding entry (see getClosestEntry).
          * Contains all cached values, regardless of why they are cached (retained, LRU or window).
          */
-        this.sortedEntries = new sorted_btree_1.default(undefined, SnapshotUtilities_1.compareFiniteNumbers);
+        this.sortedEntries = new sorted_btree_1.default(undefined, Common_1.compareFiniteNumbers);
         /**
          * Set of all revisions that should never be evicted.
          */
@@ -102,7 +101,7 @@ class RevisionValueCache {
         if (fromLRU !== undefined) {
             return [requestedRevision, fromLRU];
         }
-        return (_a = this.sortedEntries.nextLowerPair(requestedRevision + 1)) !== null && _a !== void 0 ? _a : undefined;
+        return (_a = this.sortedEntries.getPairOrNextLower(requestedRevision)) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
      * Caches the supplied value and guarantees it will never be evicted.

package/dist/RevisionValueCache.js.map

@@ -1 +1 @@
-{"version":3,"file":"RevisionValueCache.js","sourceRoot":"","sources":["../src/RevisionValueCache.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 BTree from 'sorted-btree';\nimport LRU from 'lru-cache';\nimport { assert, fail } from './Common';\nimport { Revision } from './LogViewer';\nimport { compareFiniteNumbers } from './SnapshotUtilities';\n\n/**\n * A cache of `TValue`s corresponding to `Revision`s.\n *\n * A value is kept in cache if it meets any of the following criteria:\n * - The revision is >= `retentionWindowStart`\n * - The value has been used recently, meaning getClosestEntry or cacheValue was called with its revision. Note that being returned\n * \t\twhen a large revision was passed to getClosestEntry does not count.\n * - The value is `retained` meaning it was provided to to constructor in retainedEntries or passed to `cacheRetainedValue`\n */\nexport class RevisionValueCache<TValue> {\n\t/**\n\t * A cache of entries for revisions.\n\t * This is sorted to allow efficient access to the nearest preceding entry (see getClosestEntry).\n\t * Contains all cached values, regardless of why they are cached (retained, LRU or window).\n\t */\n\tprivate readonly sortedEntries = new BTree<Revision, TValue>(undefined, compareFiniteNumbers);\n\n\t/**\n\t * Least recently used cache of evictable entries.\n\t * Subset of 'sortedValues` eligible for eviction:\n\t * All entries are also in `sortedValues`, and are removed from `sortedValues` when evicted from this cache.\n\t */\n\tprivate readonly evictableRevisions: LRU<Revision, TValue>;\n\n\t/**\n\t * Set of all revisions that should never be evicted.\n\t */\n\tprivate readonly retainedRevisions = new Set<Revision>();\n\n\tpublic constructor(\n\t\t/**\n\t\t * Maximum capacity for evictable cache entries (those neither marked as retained nor within the retention window).\n\t\t */\n\t\tevictableSize: number,\n\t\t/**\n\t\t * The first revision within the retention window. All entries with revisions >= retentionWindowStart will be retained.\n\t\t * Must be >= 0.\n\t\t */\n\t\tprivate retentionWindowStart: Revision,\n\t\t/**\n\t\t * Optional list of entries to permanently retain.\n\t\t */\n\t\tretainedEntries?: [Revision, TValue][]\n\t) {\n\t\tassert(retentionWindowStart >= 0, 'retentionWindowStart must be initialized >= 0');\n\t\tthis.evictableRevisions = new LRU({\n\t\t\tmax: evictableSize,\n\t\t\tnoDisposeOnSet: true,\n\t\t\tdispose: (revision) => {\n\t\t\t\tif (revision >= this.retentionWindowStart) {\n\t\t\t\t\tfail('Entries in retention window should never be evicted.');\n\t\t\t\t}\n\t\t\t\tif (this.retainedRevisions.has(revision)) {\n\t\t\t\t\tfail('Retained entries should not be evicted');\n\t\t\t\t}\n\t\t\t\tthis.sortedEntries.delete(revision);\n\t\t\t},\n\t\t});\n\t\tif (retainedEntries !== undefined) {\n\t\t\tretainedEntries.forEach(([revision, entry]) => this.cacheRetainedValue(revision, entry));\n\t\t}\n\t}\n\n\t/**\n\t * @returns if the supplied revision is within the retention window.\n\t */\n\tpublic isWithinRetentionWindow(revision: Revision): boolean {\n\t\treturn revision >= this.retentionWindowStart;\n\t}\n\n\t/**\n\t * Sets the new retention window.\n\t * @param newRetentionWindowStart - defines the trailing edge (inclusive) of the new retention window.\n\t */\n\tpublic updateRetentionWindow(newRetentionWindowStart: Revision): void {\n\t\tif (newRetentionWindowStart < this.retentionWindowStart) {\n\t\t\tfail('retention window boundary must not move backwards');\n\t\t}\n\t\tconst prevRetentionWindowStart = this.retentionWindowStart;\n\t\tthis.retentionWindowStart = newRetentionWindowStart;\n\t\tconst oldWindowEntries: [Revision, TValue][] = [];\n\t\tthis.sortedEntries.forRange(\n\t\t\tprevRetentionWindowStart,\n\t\t\tthis.retentionWindowStart,\n\t\t\tfalse,\n\t\t\t(windowRevision, windowEntry) => {\n\t\t\t\tif (!this.retainedRevisions.has(windowRevision)) {\n\t\t\t\t\t// Adding to the LRU can cause eviction which in turn mutates the b-tree we are enumerating. Thus, store list of\n\t\t\t\t\t// old window entries separately.\n\t\t\t\t\toldWindowEntries.push([windowRevision, windowEntry]);\n\t\t\t\t}\n\t\t\t}\n\t\t);\n\t\toldWindowEntries.forEach(([revision, value]) => {\n\t\t\tthis.evictableRevisions.set(revision, value);\n\t\t});\n\t}\n\n\t/**\n\t * @returns a [cachedRevision, value] where cachedRevision <= requestedRevision, or undefined if no such revision is cached.\n\t */\n\tpublic getClosestEntry(requestedRevision: Revision): [revision: Revision, value: TValue] | undefined {\n\t\tconst fromLRU = this.evictableRevisions.get(requestedRevision);\n\t\tif (fromLRU !== undefined) {\n\t\t\treturn [requestedRevision, fromLRU];\n\t\t}\n\t\treturn this.sortedEntries.nextLowerPair(requestedRevision + 1) ?? undefined;\n\t}\n\n\t/**\n\t * Caches the supplied value and guarantees it will never be evicted.\n\t */\n\tpublic cacheRetainedValue(revision: Revision, value: TValue): void {\n\t\tthis.retainedRevisions.add(revision);\n\t\tthis.sortedEntries.set(revision, value);\n\t}\n\n\t/**\n\t * Caches the supplied value.\n\t * The cached value is subject to eviction unless it is within the retention window or was previously added\n\t * via `cacheRetainedValue`.\n\t * Note that if a non-retained entry starts out within the retention window and passes outside of it due to a call to\n\t * updateRetentionWindow it is then subject to eviction.\n\t */\n\tpublic cacheValue(revision: Revision, value: TValue): void {\n\t\tif (this.retainedRevisions.has(revision)) {\n\t\t\treturn;\n\t\t}\n\t\tthis.sortedEntries.set(revision, value);\n\t\tif (revision < this.retentionWindowStart) {\n\t\t\tthis.evictableRevisions.set(revision, value);\n\t\t}\n\t}\n}\n"]}
+{"version":3,"file":"RevisionValueCache.js","sourceRoot":"","sources":["../src/RevisionValueCache.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 BTree from 'sorted-btree';\nimport LRU from 'lru-cache';\nimport { assert, fail, compareFiniteNumbers } from './Common';\n\n/**\n * A revision corresponds to an index in an `EditLog`.\n *\n * It is associated with the output `RevisionView` of applying the edit at the index to the previous revision.\n * For example:\n *  - revision 0 corresponds to the initialRevision.\n *  - revision 1 corresponds to the output of editLog[0] applied to the initialRevision.\n */\nexport type Revision = number;\n\n/**\n * A cache of `TValue`s corresponding to `Revision`s.\n *\n * A value is kept in cache if it meets any of the following criteria:\n * - The revision is >= `retentionWindowStart`\n * - The value has been used recently, meaning getClosestEntry or cacheValue was called with its revision. Note that being returned\n * \t\twhen a large revision was passed to getClosestEntry does not count.\n * - The value is `retained` meaning it was provided to to constructor in retainedEntries or passed to `cacheRetainedValue`\n */\nexport class RevisionValueCache<TValue> {\n\t/**\n\t * A cache of entries for revisions.\n\t * This is sorted to allow efficient access to the nearest preceding entry (see getClosestEntry).\n\t * Contains all cached values, regardless of why they are cached (retained, LRU or window).\n\t */\n\tprivate readonly sortedEntries = new BTree<Revision, TValue>(undefined, compareFiniteNumbers);\n\n\t/**\n\t * Cache of most recently used evictable entries.\n\t * Subset of 'sortedValues` eligible for eviction:\n\t * All entries are also in `sortedValues`, and are removed from `sortedValues` when evicted from this cache.\n\t * Evicts least recently used entries.\n\t */\n\tprivate readonly evictableRevisions: LRU<Revision, TValue>;\n\n\t/**\n\t * Set of all revisions that should never be evicted.\n\t */\n\tprivate readonly retainedRevisions = new Set<Revision>();\n\n\tpublic constructor(\n\t\t/**\n\t\t * Maximum capacity for evictable cache entries (those neither marked as retained nor within the retention window).\n\t\t */\n\t\tevictableSize: number,\n\t\t/**\n\t\t * The first revision within the retention window. All entries with revisions >= retentionWindowStart will be retained.\n\t\t * Must be >= 0.\n\t\t */\n\t\tprivate retentionWindowStart: Revision,\n\t\t/**\n\t\t * Optional list of entries to permanently retain.\n\t\t */\n\t\tretainedEntries?: [Revision, TValue][]\n\t) {\n\t\tassert(retentionWindowStart >= 0, 'retentionWindowStart must be initialized >= 0');\n\t\tthis.evictableRevisions = new LRU({\n\t\t\tmax: evictableSize,\n\t\t\tnoDisposeOnSet: true,\n\t\t\tdispose: (revision) => {\n\t\t\t\tif (revision >= this.retentionWindowStart) {\n\t\t\t\t\tfail('Entries in retention window should never be evicted.');\n\t\t\t\t}\n\t\t\t\tif (this.retainedRevisions.has(revision)) {\n\t\t\t\t\tfail('Retained entries should not be evicted');\n\t\t\t\t}\n\t\t\t\tthis.sortedEntries.delete(revision);\n\t\t\t},\n\t\t});\n\t\tif (retainedEntries !== undefined) {\n\t\t\tretainedEntries.forEach(([revision, entry]) => this.cacheRetainedValue(revision, entry));\n\t\t}\n\t}\n\n\t/**\n\t * @returns if the supplied revision is within the retention window.\n\t */\n\tpublic isWithinRetentionWindow(revision: Revision): boolean {\n\t\treturn revision >= this.retentionWindowStart;\n\t}\n\n\t/**\n\t * Sets the new retention window.\n\t * @param newRetentionWindowStart - defines the trailing edge (inclusive) of the new retention window.\n\t */\n\tpublic updateRetentionWindow(newRetentionWindowStart: Revision): void {\n\t\tif (newRetentionWindowStart < this.retentionWindowStart) {\n\t\t\tfail('retention window boundary must not move backwards');\n\t\t}\n\t\tconst prevRetentionWindowStart = this.retentionWindowStart;\n\t\tthis.retentionWindowStart = newRetentionWindowStart;\n\t\tconst oldWindowEntries: [Revision, TValue][] = [];\n\t\tthis.sortedEntries.forRange(\n\t\t\tprevRetentionWindowStart,\n\t\t\tthis.retentionWindowStart,\n\t\t\tfalse,\n\t\t\t(windowRevision, windowEntry) => {\n\t\t\t\tif (!this.retainedRevisions.has(windowRevision)) {\n\t\t\t\t\t// Adding to the LRU can cause eviction which in turn mutates the b-tree we are enumerating. Thus, store list of\n\t\t\t\t\t// old window entries separately.\n\t\t\t\t\toldWindowEntries.push([windowRevision, windowEntry]);\n\t\t\t\t}\n\t\t\t}\n\t\t);\n\t\toldWindowEntries.forEach(([revision, value]) => {\n\t\t\tthis.evictableRevisions.set(revision, value);\n\t\t});\n\t}\n\n\t/**\n\t * @returns a [cachedRevision, value] where cachedRevision <= requestedRevision, or undefined if no such revision is cached.\n\t */\n\tpublic getClosestEntry(requestedRevision: Revision): [revision: Revision, value: TValue] | undefined {\n\t\tconst fromLRU = this.evictableRevisions.get(requestedRevision);\n\t\tif (fromLRU !== undefined) {\n\t\t\treturn [requestedRevision, fromLRU];\n\t\t}\n\t\treturn this.sortedEntries.getPairOrNextLower(requestedRevision) ?? undefined;\n\t}\n\n\t/**\n\t * Caches the supplied value and guarantees it will never be evicted.\n\t */\n\tpublic cacheRetainedValue(revision: Revision, value: TValue): void {\n\t\tthis.retainedRevisions.add(revision);\n\t\tthis.sortedEntries.set(revision, value);\n\t}\n\n\t/**\n\t * Caches the supplied value.\n\t * The cached value is subject to eviction unless it is within the retention window or was previously added\n\t * via `cacheRetainedValue`.\n\t * Note that if a non-retained entry starts out within the retention window and passes outside of it due to a call to\n\t * updateRetentionWindow it is then subject to eviction.\n\t */\n\tpublic cacheValue(revision: Revision, value: TValue): void {\n\t\tif (this.retainedRevisions.has(revision)) {\n\t\t\treturn;\n\t\t}\n\t\tthis.sortedEntries.set(revision, value);\n\t\tif (revision < this.retentionWindowStart) {\n\t\t\tthis.evictableRevisions.set(revision, value);\n\t\t}\n\t}\n}\n"]}

package/dist/RevisionView.d.ts

@@ -0,0 +1,83 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { NodeId, StableNodeId, TraitLabel } from './Identifiers';
+import { NodeIdConverter } from './NodeIdUtilities';
+import { Payload, TreeNode } from './persisted-types';
+import { TreeView, TreeViewNode, TreeViewPlace, TreeViewRange } from './TreeView';
+import { HasVariadicTraits } from './ChangeTypes';
+/**
+ * An immutable view of a distributed tree.
+ * @public
+ */
+export declare class RevisionView extends TreeView {
+    /**
+     * Constructs a {@link RevisionView} using the supplied tree.
+     * @param root - the root of the tree to use as the contents of the {@link RevisionView}
+     * @param expensiveValidation - whether or not to perform additional validation, e.g. to catch errors when testing
+     */
+    static fromTree<T extends TreeNode<T, NodeId>>(root: T, expensiveValidation?: boolean): RevisionView;
+    /**
+     * Constructs a {@link RevisionView} using the supplied tree.
+     * @param root - the root of the tree to use as the contents of the `RevisionView`
+     * @param idConverter - the {@link NodeIdConverter} that will recompress the IDs the in the tree
+     * @param expensiveValidation - whether or not to perform additional validation, e.g. to catch errors when testing
+     */
+    static fromTree<T extends TreeNode<T, StableNodeId>>(root: T, idConverter: NodeIdConverter, expensiveValidation?: boolean): RevisionView;
+    /** Begin a transaction by generating a mutable `TransactionView` from this view */
+    openForTransaction(): TransactionView;
+    equals(view: TreeView): boolean;
+}
+/**
+ * An view of a distributed tree that is part of an ongoing transaction between `RevisionView`s.
+ * @public
+ */
+export declare class TransactionView extends TreeView {
+    /** Conclude a transaction by generating an immutable `RevisionView` from this view */
+    close(): RevisionView;
+    /** Inserts all nodes in a NodeSequence into the view */
+    addNodes(sequence: Iterable<TreeViewNode>): TransactionView;
+    /** Remove all nodes with the given ids from the view */
+    deleteNodes(nodes: Iterable<NodeId>): TransactionView;
+    /**
+     * Parents a set of detached nodes at a specified place.
+     * @param nodesToAttach - the nodes to parent in the specified place. The nodes must already be present in the view.
+     * @param place - the location to insert the nodes.
+     */
+    attachRange(nodesToAttach: readonly NodeId[], place: TreeViewPlace): TransactionView;
+    /**
+     * Detaches a range of nodes from their parent. The detached nodes remain in the view.
+     * @param rangeToDetach - the range of nodes to detach
+     */
+    detachRange(rangeToDetach: TreeViewRange): {
+        view: TransactionView;
+        detached: readonly NodeId[];
+    };
+    /**
+     * Sets or overwrites a node's value. The node must exist in this view.
+     * @param nodeId - the id of the node
+     * @param value - the new value
+     */
+    setNodeValue(nodeId: NodeId, value: Payload): TransactionView;
+    equals(view: TreeView): boolean;
+}
+/**
+ * Transform an input tree into a list of {@link TreeViewNode}s.
+ * @param tree - the input tree
+ * @param convert - a conversion function that will run on each node in the input tree to produce the output nodes.
+ * Returning undefined means that conversion for the given node was impossible, at which time the entire tree conversion will be aborted
+ * and return undefined.
+ */
+export declare function convertTreeNodesToViewNodes<TIn extends HasVariadicTraits<TIn>, TOut extends TreeViewNode = TreeViewNode>(root: TIn, convert: (node: TIn) => Omit<TOut, 'traits'>): TOut[];
+/**
+ * Transform an input tree into a list of {@link TreeViewNode}s.
+ * @param tree - the input tree
+ * @param convert - a conversion function that will run on each node in the input tree to produce the output nodes.
+ */
+export declare function convertTreeNodesToViewNodes<TIn extends HasVariadicTraits<TIn>, TOut extends TreeViewNode = TreeViewNode>(root: TIn, convert: (node: TIn) => Omit<TOut, 'traits'> | undefined): TOut[] | undefined;
+/**
+ * Returns an iterable of the supplied node's traits in a stable order.
+ */
+export declare function iterateChildren<T>(hasTraits: HasVariadicTraits<T>): Iterable<[TraitLabel, T]>;
+//# sourceMappingURL=RevisionView.d.ts.map

package/dist/RevisionView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RevisionView.d.ts","sourceRoot":"","sources":["../src/RevisionView.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAoB,MAAM,mBAAmB,CAAC;AACxE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAElD;;;GAGG;AACH,qBAAa,YAAa,SAAQ,QAAQ;IACzC;;;;OAIG;WACW,QAAQ,CAAC,CAAC,SAAS,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,mBAAmB,CAAC,EAAE,OAAO,GAAG,YAAY;IAC3G;;;;;OAKG;WACW,QAAQ,CAAC,CAAC,SAAS,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC,EACzD,IAAI,EAAE,CAAC,EACP,WAAW,EAAE,eAAe,EAC5B,mBAAmB,CAAC,EAAE,OAAO,GAC3B,YAAY;IAsCf,mFAAmF;IAC5E,kBAAkB,IAAI,eAAe;IAIrC,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO;CAOtC;AAED;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,QAAQ;IAC5C,sFAAsF;IAC/E,KAAK,IAAI,YAAY;IAI5B,wDAAwD;IACjD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,eAAe;IAIlE,wDAAwD;IACjD,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,eAAe;IAI5D;;;;OAIG;IACI,WAAW,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,aAAa,GAAG,eAAe;IAM3F;;;OAGG;IACI,WAAW,CAAC,aAAa,EAAE,aAAa,GAAG;QAAE,IAAI,EAAE,eAAe,CAAC;QAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE;IAUxG;;;;OAIG;IACI,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,eAAe;IAI7D,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO;CAOtC;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAC1C,GAAG,SAAS,iBAAiB,CAAC,GAAG,CAAC,EAClC,IAAI,SAAS,YAAY,GAAG,YAAY,EACvC,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,IAAI,EAAE,CAAC;AAEnE;;;;GAIG;AACH,wBAAgB,2BAA2B,CAC1C,GAAG,SAAS,iBAAiB,CAAC,GAAG,CAAC,EAClC,IAAI,SAAS,YAAY,GAAG,YAAY,EACvC,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,SAAS,GAAG,IAAI,EAAE,GAAG,SAAS,CAAC;AA6D3F;;GAEG;AACH,wBAAiB,eAAe,CAAC,CAAC,EAAE,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAc9F"}