@fluid-experimental/tree 0.58.2001 → 0.59.2000-61729

package/dist/LazyCheckout.js

@@ -0,0 +1,44 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyCheckout = void 0;
+const Checkout_1 = require("./Checkout");
+/**
+ * Checkout that only updates its view of the tree when explicitly requested.
+ * This means that the {@link Checkout.currentView} field will never change unless {@link LazyCheckout.waitForPendingUpdates} is called.
+ *
+ * @public
+ * @sealed
+ */
+class LazyCheckout extends Checkout_1.Checkout {
+    /**
+     * @param tree - the tree
+     */
+    constructor(tree) {
+        super(tree, tree.currentView, (args) => { });
+        this.latestView = tree.currentView;
+    }
+    handleNewEdit(id, result) {
+        super.handleNewEdit(id, result);
+        this.latestView = result.after;
+    }
+    get latestCommittedView() {
+        return this.latestView;
+    }
+    async waitForPendingUpdates() {
+        if (this.tree.currentView !== this.latestView) {
+            this.latestView = this.tree.currentView;
+            this.emitChange();
+        }
+        return Promise.resolve();
+    }
+    async waitForEditsToSubmit() {
+        // This checkout is only lazy on updates, not edit application, so it does not need to wait for here.
+        return Promise.resolve();
+    }
+}
+exports.LazyCheckout = LazyCheckout;
+//# sourceMappingURL=LazyCheckout.js.map

package/dist/LazyCheckout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LazyCheckout.js","sourceRoot":"","sources":["../src/LazyCheckout.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,yCAAsC;AAMtC;;;;;;GAMG;AACH,MAAa,YAAa,SAAQ,mBAAQ;IAGzC;;OAEG;IACH,YAAmB,IAAgB;QAClC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,IAAiC,EAAE,EAAE,GAAE,CAAC,CAAC,CAAC;QACzE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC;IACpC,CAAC;IAES,aAAa,CAAC,EAAU,EAAE,MAA0B;QAC7D,KAAK,CAAC,aAAa,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;QAChC,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC;IAChC,CAAC;IAED,IAAc,mBAAmB;QAChC,OAAO,IAAI,CAAC,UAAU,CAAC;IACxB,CAAC;IAEM,KAAK,CAAC,qBAAqB;QACjC,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC,UAAU,EAAE;YAC9C,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC;YACxC,IAAI,CAAC,UAAU,EAAE,CAAC;SAClB;QACD,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC1B,CAAC;IAEM,KAAK,CAAC,oBAAoB;QAChC,qGAAqG;QACrG,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC1B,CAAC;CACD;AAhCD,oCAgCC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { Checkout } from './Checkout';\nimport { EditId } from './Identifiers';\nimport { RevisionView } from './RevisionView';\nimport { EditCommittedEventArguments, SharedTree } from './SharedTree';\nimport { ValidEditingResult } from './TransactionInternal';\n\n/**\n * Checkout that only updates its view of the tree when explicitly requested.\n * This means that the {@link Checkout.currentView} field will never change unless {@link LazyCheckout.waitForPendingUpdates} is called.\n *\n * @public\n * @sealed\n */\nexport class LazyCheckout extends Checkout {\n\tprivate latestView: RevisionView;\n\n\t/**\n\t * @param tree - the tree\n\t */\n\tpublic constructor(tree: SharedTree) {\n\t\tsuper(tree, tree.currentView, (args: EditCommittedEventArguments) => {});\n\t\tthis.latestView = tree.currentView;\n\t}\n\n\tprotected handleNewEdit(id: EditId, result: ValidEditingResult): void {\n\t\tsuper.handleNewEdit(id, result);\n\t\tthis.latestView = result.after;\n\t}\n\n\tprotected get latestCommittedView(): RevisionView {\n\t\treturn this.latestView;\n\t}\n\n\tpublic async waitForPendingUpdates(): Promise<void> {\n\t\tif (this.tree.currentView !== this.latestView) {\n\t\t\tthis.latestView = this.tree.currentView;\n\t\t\tthis.emitChange();\n\t\t}\n\t\treturn Promise.resolve();\n\t}\n\n\tpublic async waitForEditsToSubmit(): Promise<void> {\n\t\t// This checkout is only lazy on updates, not edit application, so it does not need to wait for here.\n\t\treturn Promise.resolve();\n\t}\n}\n"]}

package/dist/LogViewer.d.ts

@@ -2,17 +2,18 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { ITelemetryBaseLogger } from '@fluidframework/common-definitions';
 import { EditLog } from './EditLog';
-import { Snapshot } from './Snapshot';
-import { Edit, EditStatus, EditingResult, GenericTransaction } from './generic';
 import { EditId } from './Identifiers';
-import { ReconciliationPath } from './ReconciliationPath';
+import { Revision } from './RevisionValueCache';
+import { ReconciliationChange, ReconciliationPath } from './ReconciliationPath';
+import { ChangeInternal, Edit, EditStatus } from './persisted-types';
+import { RevisionView } from './RevisionView';
+import { EditingResult, TransactionInternal } from './TransactionInternal';
 /**
- * Callback for when an edit is applied (meaning the result of applying it to a particular snapshot is computed).
+ * Callback for when an edit is applied (meaning the result of applying it to a particular revision is computed).
  *
- * Edits may be applied any time a Snapshot is computed that includes them.
- * Depending on the caching policy of the LogViewer, a given edit may or may not be applied in order to compute a Snapshot containing it.
+ * Edits may be applied any time a TreeView is computed that includes them.
+ * Depending on the caching policy of the LogViewer, a given edit may or may not be applied in order to compute a TreeView containing it.
  *
  * If the same edit occurs in different contexts (ex: a local edit is adjusted for a new remote edit),
  * that it will be reapplied, and this may result in different results.
@@ -29,56 +30,76 @@ import { ReconciliationPath } from './ReconciliationPath';
  */
 export declare type EditStatusCallback = (editResult: EditStatus, editId: EditId, wasCached: boolean) => void;
 /**
- * Result of applying an identified transaction.
- * @public
+ * Callback for when a sequenced edit is applied.
+ * This includes local edits though the callback is only invoked once the sequenced version is received.
+ *
+ * For edits that were local (see {@link SequencedEditResult.wasLocal}, this callback will only be called once.
+ * For non-local edits, it may be called multiple times: the number of calls and when they occur depends on caching and is an implementation
+ * detail.
+ */
+export declare type SequencedEditResultCallback = (args: SequencedEditResult) => void;
+/**
+ * The relevant information pertaining to the application of a sequenced edit.
  */
-export declare type EditingResultWithId<TChange> = EditingResult<TChange> & {
+export interface SequencedEditResult {
     /**
-     * Unique identifier for this edit. Must never be reused.
-     * Used for referencing and de-duplicating edits.
+     * The edit that was applied.
      */
-    readonly id: EditId;
-};
+    edit: Edit<ChangeInternal>;
+    /**
+     * true iff the edit was local.
+     */
+    wasLocal: boolean;
+    /**
+     * The result of applying the edit.
+     */
+    result: AttemptedEditResultCacheEntry;
+    /**
+     * The reconciliation path for the edit.
+     */
+    reconciliationPath: ReconciliationPath;
+}
 /**
  * The data cached by `CachingLogViewer` for an edit.
  */
-export declare type EditCacheEntry<TChange> = SuccessfulEditCacheEntry<TChange> | UnsuccessfulEditCacheEntry | SummarizedEditResultCacheEntry;
+export declare type EditCacheEntry = SuccessfulEditCacheEntry | UnsuccessfulEditCacheEntry | SummarizedEditResultCacheEntry;
 /**
  * The data cached by `CachingLogViewer` for an edit that it has attempted to apply locally.
  */
-export declare type AttemptedEditResultCacheEntry<TChange> = SuccessfulEditCacheEntry<TChange> | UnsuccessfulEditCacheEntry;
+export declare type AttemptedEditResultCacheEntry = SuccessfulEditCacheEntry | UnsuccessfulEditCacheEntry;
 /**
  * The data cached by `CachingLogViewer` for an edit that it has successfully applied locally.
  */
-export interface SuccessfulEditCacheEntry<TChange> {
+export interface SuccessfulEditCacheEntry {
     /**
-     * The snapshot resulting from the edit.
+     * The revision view resulting from the edit.
      */
-    snapshot: Snapshot;
+    readonly view: RevisionView;
     /**
-     * The status code for the edit that produced the snapshot.
+     * The status code for the edit that produced the revision.
      */
-    status: EditStatus.Applied;
+    readonly status: EditStatus.Applied;
     /**
      * The resolved changes that were applied during the edit and their associated outcome.
      */
-    steps: readonly {
-        resolvedChange: TChange;
-        after: Snapshot;
-    }[];
+    readonly steps: readonly ReconciliationChange[];
 }
 /**
  * The data cached by `CachingLogViewer` for an edit that it has unsuccessfully attempted to apply locally.
  */
 export interface UnsuccessfulEditCacheEntry {
     /**
-     * The snapshot resulting from the edit.
+     * The revision view resulting from the edit.
+     */
+    readonly view: RevisionView;
+    /**
+     * The status code for the edit that produced the revision.
      */
-    readonly snapshot: Snapshot;
+    readonly status: EditStatus.Invalid | EditStatus.Malformed;
     /**
-     * The status code for the edit that produced the snapshot.
+     * Information about the failure encountered by the edit
      */
-    status: EditStatus.Invalid | EditStatus.Malformed;
+    readonly failure: TransactionInternal.Failure;
 }
 /**
  * The data cached by `CachingLogViewer` for an edit that it has retrieved from a summary.
@@ -86,64 +107,77 @@ export interface UnsuccessfulEditCacheEntry {
  */
 export interface SummarizedEditResultCacheEntry {
     /**
-     * The snapshot resulting from the edit.
+     * The revision view resulting from the edit.
+     */
+    readonly view: RevisionView;
+    /**
+     * Not specified on `SummarizedEditResultCacheEntry`.
+     * Declared to allow checking `entry.status` against undefined.
      */
-    snapshot: Snapshot;
-    status?: undefined;
+    readonly status?: never;
 }
+export declare type CachedEditingResult = AttemptedEditResultCacheEntry & {
+    /**
+     * Unique identifier for this edit. Must never be reused.
+     * Used for referencing and de-duplicating edits.
+     */
+    readonly id: EditId;
+    readonly before: RevisionView;
+    readonly changes: readonly ChangeInternal[];
+};
 /**
- * A revision corresponds to an index in an `EditLog`.
- *
- * It is associated with the output `Snapshot` of applying the edit at the index to the previous revision.
- * For example:
- *  - revision 0 corresponds to the initialSnapshot.
- *  - revision 1 corresponds to the output of editLog[0] applied to the initialSnapshot.
- */
-export declare type Revision = number;
-/**
- * Creates `Snapshot`s for the revisions in an `EditLog`
+ * Creates `RevisionView`s for the revisions in an `EditLog`
  */
 export interface LogViewer {
     /**
-     * Returns the `Snapshot` output associated with the largest revision in `editLog` less than (but not equal to) the supplied revision.
+     * Returns the `TreeView` output associated with the largest revision in `editLog` less than (but not equal to) the supplied revision.
      *
      * For example:
-     *  - revision 0 returns the initialSnapshot.
-     *  - revision 1 returns the output of editLog[0] (or initialSnapshot if there is no edit 0).
+     *  - revision 0 returns the initialRevision.
+     *  - revision 1 returns the output of editLog[0] (or initialRevision if there is no edit 0).
      *  - revision Number.POSITIVE_INFINITY returns the newest revision.
      */
-    getSnapshot(revision: Revision): Promise<Snapshot>;
+    getRevisionView(revision: Revision): Promise<RevisionView>;
     /**
-     * Returns the `Snapshot` output associated with the largest revision in `editLog` less than (but not equal to) the supplied revision.
+     * Returns the `TreeView` output associated with the largest revision in `editLog` less than (but not equal to) the supplied revision.
      * Can only be used to retrieve revisions added during the current sessions.
      *
      * For example:
-     *  - revision 0 returns the initialSnapshot.
-     *  - revision 1 returns the output of editLog[0] (or initialSnapshot if there is no edit 0).
+     *  - revision 0 returns the initialRevision.
+     *  - revision 1 returns the output of editLog[0] (or initialRevision if there is no edit 0).
      *  - revision Number.POSITIVE_INFINITY returns the newest revision.
      */
-    getSnapshotInSession(revision: Revision): Snapshot;
+    getRevisionViewInSession(revision: Revision): RevisionView;
 }
 /**
- * Creates Snapshots for revisions associated with an EditLog and caches the results.
+ * Creates views for revisions associated with an EditLog and caches the results.
+ *
+ * Does so by listening for edits added to the log. If the underlying EditLog or its listeners need to be reused beyond the lifetime of
+ * a CachingLogViewer instance, that instance should be disposed with `detachFromEditLog` to ensure it is garbage-collectable.
  * @internal
  */
-export declare class CachingLogViewer<TChange> implements LogViewer {
-    readonly log: EditLog<TChange>;
+export declare class CachingLogViewer implements LogViewer {
+    readonly log: EditLog<ChangeInternal>;
     /**
-     * Maximum size of the sequenced snapshot cache.
+     * Maximum size of the sequenced revision cache.
      */
     static readonly sequencedCacheSizeMax = 50;
     /**
-     * A cache for local snapshots.
+     * A cache for local revisions.
      * It is invalidated whenever a new sequenced edit (that was not already a local edit) is added to the log.
      * When a previously local edit is sequenced, this cache is adjusted to account for it, not invalidated.
      */
-    private readonly localSnapshotCache;
+    private readonly localRevisionCache;
+    /**
+     * Cache of sequenced revisions.
+     */
+    private readonly sequencedRevisionCache;
     /**
-     * Cache of sequenced snapshots.
+     * Called whenever a sequenced edit is applied.
+     * This will have been called at least once for any edit if a revision after than edit has been requested.
+     * It may be called multiple times: the number of calls and when they occur depends on caching and is an implementation detail.
      */
-    private readonly sequencedSnapshotCache;
+    private readonly processSequencedEditResult;
     /**
      * Called whenever an edit is processed.
      * This will have been called at least once for any edit if a revision after than edit has been requested.
@@ -154,10 +188,6 @@ export declare class CachingLogViewer<TChange> implements LogViewer {
      * Iff true, additional correctness assertions will be run during LogViewer operations.
      */
     private readonly expensiveValidation;
-    /**
-     * Telemetry logger, used to log events such as edit application rejection.
-     */
-    private readonly logger;
     /**
      * The ordered queue of edits that originated from this client that have never been applied (by this log viewer) in a sequenced state.
      * This means these edits may be local or sequenced, and may have been applied (possibly multiple times) while still local.
@@ -171,28 +201,40 @@ export declare class CachingLogViewer<TChange> implements LogViewer {
      * This cache helps optimize that case by avoiding recomputing the edit if no other edits were added during the transaction.
      */
     private cachedEditResult?;
-    private readonly transactionFactory;
+    /**
+     * Cache entry for the highest revision.
+     * `undefined` when not cached.
+     */
+    private highestRevisionCacheEntry?;
+    /**
+     * Removes this log viewer from the set of handleEditAdded listeners on its underlying log.
+     * This should be called if the underlying log or its listeners are re-used past the lifetime of this log viewer.
+     */
+    readonly detachFromEditLog: () => void;
+    /**
+     * @returns true if the highest revision is cached.
+     */
+    highestRevisionCached(): boolean;
     /**
      * Create a new LogViewer
-     * @param log - the edit log which snapshots will be based on.
-     * @param baseTree - the tree used in the snapshot corresponding to the 0th revision. Defaults to `initialTree`.
-     * @param knownRevisions - a set of [sequencedRevision, snapshot] pairs that are known (have been precomputed) at construction time.
+     * @param log - the edit log which revisions will be based on.
+     * @param baseTree - the tree used in the view corresponding to the 0th revision.
+     * @param knownRevisions - a set of [sequencedRevision, view] pairs that are known (have been precomputed) at construction time.
      * These revisions are guaranteed to never be evicted from the cache.
      * @param expensiveValidation - Iff true, additional correctness assertions will be run during LogViewer operations.
      * @param processEditStatus - called after applying an edit.
-     * @param logger - used to log telemetry
+     * @param processSequencedEditResult - called after applying a sequenced edit.
      */
-    constructor(log: EditLog<TChange>, baseSnapshot: Snapshot | undefined, knownRevisions: [number, EditCacheEntry<TChange>][] | undefined, expensiveValidation: boolean | undefined, processEditStatus: EditStatusCallback | undefined, logger: ITelemetryBaseLogger, transactionFactory: (snapshot: Snapshot) => GenericTransaction<TChange>, minimumSequenceNumber?: number);
+    constructor(log: EditLog<ChangeInternal>, baseView: RevisionView, knownRevisions?: [Revision, EditCacheEntry][], expensiveValidation?: boolean, processEditStatus?: EditStatusCallback, processSequencedEditResult?: SequencedEditResultCallback, minimumSequenceNumber?: number);
     /**
-     * Performs the tracking needed to log telemetry about failed (invalid/malformed) local edits when they are sequenced.
-     * As a performance optimization, this method also caches snapshots generated by local edits if they are sequenced without
+     * As a performance optimization, this method caches views generated by local edits if they are sequenced without
      * being interleaved with remote edits.
      */
     private handleEditAdded;
-    getEditResult(revision: Revision): Promise<EditCacheEntry<TChange>>;
-    getSnapshot(revision: Revision): Promise<Snapshot>;
-    getEditResultInSession(revision: Revision): EditCacheEntry<TChange>;
-    getSnapshotInSession(revision: Revision): Snapshot;
+    getEditResult(revision: Revision): Promise<EditCacheEntry>;
+    getRevisionView(revision: Revision): Promise<RevisionView>;
+    getEditResultInSession(revision: Revision): EditCacheEntry;
+    getRevisionViewInSession(revision: Revision): RevisionView;
     /**
      * Informs the CachingLogViewer of the latest known minimumSequenceNumber for all connected clients.
      * This can be used to provide more aggressive caching of revisions within the collaboration window, as those revisions
@@ -201,24 +243,25 @@ export declare class CachingLogViewer<TChange> implements LogViewer {
      */
     setMinimumSequenceNumber(minimumSequenceNumber: number): void;
     /**
-     * Inform the CachingLogViewer that a particular edit is know to have a specific result when applied to a particular Snapshot.
-     * LogViewer may use this information to as a optimization to avoid re-running the edit if re-applied to the same Snapshot.
+     * Inform the CachingLogViewer that a particular edit is known to have a specific result when applied to a particular TreeView.
+     * CachingLogViewer may use this information as an optimization to avoid re-running the edit if re-applied to the same TreeView.
      */
-    setKnownEditingResult(edit: Edit<TChange>, result: EditingResult<TChange>): void;
+    setKnownEditingResult(edit: Edit<ChangeInternal>, result: EditingResult): void;
     /**
-     * @returns the cached snapshot closest to the requested `revision`.
+     * @returns the cached revision view closest to the requested `revision`.
      */
     private getStartingPoint;
     /**
-     * Helper for applying an edit at the supplied snapshot.
+     * Helper for applying an edit at the supplied revision view.
      * Must only be called in the order that edits appear in the log.
      * Must only be called once for a given local edit as long as the local cache has not been invalidated.
      * Must only be called once for a given sequenced edit.
-     * @returns the resulting snapshot and the outcome of edit that produced it.
+     * @returns the resulting revision view and the outcome of edit that produced it.
      */
     private applyEdit;
     /**
-     * Helper for performing caching and telemetry logging when a sequenced local edit is first applied.
+     * Helper for performing caching when a sequenced local edit is first applied.
+     * Invokes the `processSequencedEditResult` handler that was passed to the constructor (if any).
      * Must only be called for non-cached sequenced edits.
      */
     private handleSequencedEditResult;
@@ -228,12 +271,12 @@ export declare class CachingLogViewer<TChange> implements LogViewer {
      * yet supported.
      * @param editId - The ID for the edit to get the reconciliation path for.
      */
-    reconciliationPathFromEdit(editId: EditId): ReconciliationPath<TChange>;
+    reconciliationPathFromEdit(editId: EditId): ReconciliationPath;
     /**
      * @returns Edit information for the earliest known sequenced edit.
      */
     earliestSequencedEditInSession(): {
-        edit: Edit<TChange>;
+        edit: Edit<ChangeInternal>;
         sequenceNumber: number;
     } | undefined;
     /**
@@ -242,8 +285,9 @@ export declare class CachingLogViewer<TChange> implements LogViewer {
     private getEditResultFromIndex;
     /**
      * @param sequenceNumber - The server-assigned sequenced number assigned to the edit of interest.
-     * @returns Edit result information for the edit with the given sequence number. Undefined if no such edit is known.
+     * @returns Edit result information for the edit with the given sequence number or the nearest sequenced edit before that.
+     * Undefined if no sequenced edit occurred at or prior to the given sequenceNumber.
      */
-    getEditResultFromSequenceNumber(sequenceNumber: number): EditingResultWithId<TChange> | undefined;
+    getEditResultFromSequenceNumber(sequenceNumber: number): CachedEditingResult | undefined;
 }
 //# sourceMappingURL=LogViewer.d.ts.map

package/dist/LogViewer.d.ts.map

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