@fluidframework/tree 2.110.0 → 2.111.0

package/lib/simple-tree/api/transactionTypes.d.ts

@@ -2,6 +2,7 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+import type { ErasedType } from "@fluidframework/core-interfaces";
 import type { TreeNode } from "../core/index.js";
 /**
  * A special object that signifies when a SharedTree {@link RunTransaction | transaction} should "roll back".
@@ -43,23 +44,37 @@ export interface NoChangeConstraint {
 }
 /**
  * Contains a value returned from a transaction.
- * @alpha
+ * @input
+ * @beta
  */
 export interface WithValue<TValue> {
     /** The user-supplied value. */
-    value: TValue;
+    readonly value: TValue;
 }
 /**
- * Contains a value and status returned from a user-supplied {@link TreeBranchAlpha.(runTransaction:1) | transaction callback}.
- * @alpha
+ * Contains a value and status returned from a user-supplied {@link TreeViewBeta.runTransaction | transaction callback}.
+ * @input
+ * @beta
  */
-export type TransactionCallbackStatus<TSuccessValue, TFailureValue> = ((WithValue<TSuccessValue> & {
+export type TransactionCallbackStatusBeta<TSuccessValue, TFailureValue> = (WithValue<TSuccessValue> & {
     /** Indicates that the transaction callback ran successfully. */
-    rollback?: false;
+    readonly rollback?: false;
 }) | (WithValue<TFailureValue> & {
     /** Indicates that the transaction callback failed and the transaction should be rolled back. */
-    rollback: true;
-})) & {
+    readonly rollback: true;
+});
+/**
+ * The result of a {@link TreeViewBeta.runTransaction | transaction} that doesn't return a value.
+ * @input
+ * @beta
+ */
+export type VoidTransactionCallbackStatusBeta = Omit<TransactionCallbackStatusBeta<unknown, unknown>, "value">;
+/**
+ * {@link TransactionCallbackStatusBeta} extended with alpha-only {@link TransactionConstraintAlpha | constraint} options.
+ * @input
+ * @alpha
+ */
+export type TransactionCallbackStatusAlpha<TSuccessValue, TFailureValue> = TransactionCallbackStatusBeta<TSuccessValue, TFailureValue> & {
     /**
      * An optional list of {@link TransactionConstraintAlpha | constraints} that will be checked when the commit corresponding
      * to this transaction is reverted. If any of these constraints are not met when the revert is being applied either
@@ -67,46 +82,86 @@ export type TransactionCallbackStatus<TSuccessValue, TFailureValue> = ((WithValu
      * These constraints must also be met at the time they are first introduced. If they are not met after the transaction
      * callback returns, then `runTransaction` (which invokes the transaction callback) will throw a `UsageError`.
      */
-    preconditionsOnRevert?: readonly TransactionConstraintAlpha[];
+    readonly preconditionsOnRevert?: readonly TransactionConstraintAlpha[];
 };
 /**
  * The result of a {@link TreeBranchAlpha.(runTransaction:2) | transaction} that doesn't return a value.
+ * @input
  * @alpha
  */
-export type VoidTransactionCallbackStatus = Omit<TransactionCallbackStatus<unknown, unknown>, "value">;
+export type VoidTransactionCallbackStatusAlpha = Omit<TransactionCallbackStatusAlpha<unknown, unknown>, "value">;
 /**
- * The result of a {@link TreeBranchAlpha.(runTransaction:1) | transaction} that completed successfully.
- * @alpha
+ * The result of a {@link TreeViewBeta.(runTransaction:1) | transaction} that completed successfully.
+ * @sealed
+ * @beta
  */
 export interface TransactionResultSuccess<TSuccessValue> extends WithValue<TSuccessValue> {
-    /** The success flag for a transaction that completed without being {@link TransactionCallbackStatus | rolled back}. */
-    success: true;
+    /** The success flag for a transaction that completed without being {@link TransactionCallbackStatusBeta | rolled back}. */
+    readonly success: true;
 }
 /**
- * The result of a {@link TreeBranchAlpha.(runTransaction:1) | transaction} that was rolled back.
- * @alpha
+ * The result of a {@link TreeViewBeta.runTransaction | transaction} that was rolled back.
+ * @sealed
+ * @beta
  */
 export interface TransactionResultFailed<TFailureValue> extends WithValue<TFailureValue> {
-    /** The failure flag for a transaction that was {@link TransactionCallbackStatus | rolled back}. */
-    success: false;
+    /** The failure flag for a transaction that was {@link TransactionCallbackStatusBeta | rolled back}. */
+    readonly success: false;
 }
 /**
  * The result of the {@link RunTransaction | RunTransaction} API.
- * @alpha
+ * @sealed
+ * @beta
  */
-export type TransactionResultExt<TSuccessValue, TFailureValue> = TransactionResultSuccess<TSuccessValue> | TransactionResultFailed<TFailureValue>;
+export type TransactionValueResult<TSuccessValue, TFailureValue> = TransactionResultSuccess<TSuccessValue> | TransactionResultFailed<TFailureValue>;
 /**
- * The result of the {@link RunTransaction | RunTransaction} API. This is the same as {@link TransactionResultExt}
+ * The result of the {@link RunTransaction | RunTransaction} API. This is the same as {@link TransactionValueResult}
  * but with the `value` field omitted. This is useful when the transaction callback doesn't need to return a value.
+ * @sealed
+ * @beta
+ */
+export type TransactionVoidResult = Omit<TransactionResultSuccess<unknown>, "value"> | Omit<TransactionResultFailed<unknown>, "value">;
+/**
+ * A type-erased function that post-processes the change produced when a transaction is committed.
+ *
+ * @remarks
+ * Supply one via {@link RunTransactionParamsAlpha.postProcessor} to process/alter
+ * the change that a transaction produces. For example a post-processor could
+ * remove extraneous information, so that the resulting squashed change contains
+ * no extraneous information.
+ *
+ * This type intentionally hides its internal representation: its concrete shape
+ * is an implementation detail of `@fluidframework/tree`. Obtain a value of this
+ * type from a `@fluidframework/tree` helper or constant rather than constructing
+ * one directly.
+ *
  * @alpha
+ * @sealed
+ * @system
  */
-export type TransactionResult = Omit<TransactionResultSuccess<unknown>, "value"> | Omit<TransactionResultFailed<unknown>, "value">;
+export interface TransactionPostProcessor extends ErasedType<"@fluidframework/tree.TransactionPostProcessor"> {
+}
 /**
  * The parameters for the {@link RunTransaction | RunTransaction} API.
- * @alpha
  * @input
+ * @beta
  */
-export interface RunTransactionParams {
+export interface RunTransactionParamsBeta {
+    /**
+     * A label for this transaction that allows it to be correlated with later edits (e.g. for controlling undo/redo grouping).
+     * @remarks
+     * If this transaction is applied to a {@link TreeBranchAlpha | branch}, the label will be available in the {@link LocalChangeMetadata.label | metadata} of the {@link TreeBranchEvents.changed | `changed`} event.
+     *
+     * If there is a nested transaction, only the outermost transaction label will be used.
+     */
+    readonly label?: unknown;
+}
+/**
+ * The parameters for the {@link RunTransaction | RunTransaction} API, extended with alpha-only {@link TransactionConstraintAlpha | constraint} options.
+ * @input
+ * @alpha
+ */
+export interface RunTransactionParamsAlpha extends RunTransactionParamsBeta {
     /**
      * An optional list of {@link TransactionConstraintAlpha | constraints} that are checked just before the transaction begins.
      * @remarks
@@ -115,12 +170,20 @@ export interface RunTransactionParams {
      */
     readonly preconditions?: readonly TransactionConstraintAlpha[];
     /**
-     * A label for this transaction that allows it to be correlated with later edits (e.g. for controlling undo/redo grouping).
+     * An optional {@link TransactionPostProcessor | post-processor} applied to
+     * the change produced when this transaction is committed.
      * @remarks
-     * If this transaction is applied to a {@link TreeBranchAlpha | branch}, the label will be available in the {@link LocalChangeMetadata.label | metadata} of the {@link TreeBranchEvents.changed | `changed`} event.
+     * When omitted, the transaction's edits are squashed without any such processing.
      *
-     * If there is a nested transaction, only the outermost transaction label will be used.
+     * Specific post-processors are applied according to their own rules for
+     * optimization and other post-processing tasks in a transaction stack. For
+     * example a "minimization" post-processor may be applied once for the
+     * outermost transaction in a stack as it will process all nested edits and
+     * there is no benefit from multiple applications.
+     *
+     * Note: minimization is not yet implemented. Supplying a post-processor currently has no observable effect beyond
+     * reserving the behavior; a real post-processor will be provided in a future change.
      */
-    readonly label?: unknown;
+    readonly postProcessor?: TransactionPostProcessor;
 }
 //# sourceMappingURL=transactionTypes.d.ts.map

package/lib/simple-tree/api/transactionTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transactionTypes.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/transactionTypes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,QAAQ,eAA4C,CAAC;AAElE;;;;;;;;;GASG;AACH,MAAM,MAAM,qBAAqB,GAAG,wBAAwB,CAAC;AAE7D;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAAG,qBAAqB,GAAG,kBAAkB,CAAC;AAEpF;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IAClC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS,CAAC,MAAM;IAChC,+BAA+B;IAC/B,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,MAAM,MAAM,yBAAyB,CAAC,aAAa,EAAE,aAAa,IAAI,CACnE,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG;IAC5B,gEAAgE;IAChE,QAAQ,CAAC,EAAE,KAAK,CAAC;CAChB,CAAC,GACF,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG;IAC5B,gGAAgG;IAChG,QAAQ,EAAE,IAAI,CAAC;CACd,CAAC,CACJ,GAAG;IACH;;;;;;OAMG;IACH,qBAAqB,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAC;CAC9D,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,6BAA6B,GAAG,IAAI,CAC/C,yBAAyB,CAAC,OAAO,EAAE,OAAO,CAAC,EAC3C,OAAO,CACP,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,wBAAwB,CAAC,aAAa,CAAE,SAAQ,SAAS,CAAC,aAAa,CAAC;IACxF,uHAAuH;IACvH,OAAO,EAAE,IAAI,CAAC;CACd;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB,CAAC,aAAa,CAAE,SAAQ,SAAS,CAAC,aAAa,CAAC;IACvF,mGAAmG;IACnG,OAAO,EAAE,KAAK,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,CAAC,aAAa,EAAE,aAAa,IAC1D,wBAAwB,CAAC,aAAa,CAAC,GACvC,uBAAuB,CAAC,aAAa,CAAC,CAAC;AAE1C;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAC1B,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,GAChD,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;AAEnD;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAC/D;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CACzB"}
+{"version":3,"file":"transactionTypes.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/transactionTypes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,QAAQ,eAA4C,CAAC;AAElE;;;;;;;;;GASG;AACH,MAAM,MAAM,qBAAqB,GAAG,wBAAwB,CAAC;AAE7D;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAAG,qBAAqB,GAAG,kBAAkB,CAAC;AAEpF;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IAClC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS,CAAC,MAAM;IAChC,+BAA+B;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,MAAM,6BAA6B,CAAC,aAAa,EAAE,aAAa,IACnE,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG;IAC5B,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;CACzB,CAAC,GACF,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG;IAC5B,gGAAgG;IAChG,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;CACvB,CAAC,CAAC;AAEN;;;;GAIG;AACH,MAAM,MAAM,iCAAiC,GAAG,IAAI,CACnD,6BAA6B,CAAC,OAAO,EAAE,OAAO,CAAC,EAC/C,OAAO,CACP,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,8BAA8B,CAAC,aAAa,EAAE,aAAa,IACtE,6BAA6B,CAAC,aAAa,EAAE,aAAa,CAAC,GAAG;IAC7D;;;;;;OAMG;IACH,QAAQ,CAAC,qBAAqB,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAC;CACvE,CAAC;AAEH;;;;GAIG;AACH,MAAM,MAAM,kCAAkC,GAAG,IAAI,CACpD,8BAA8B,CAAC,OAAO,EAAE,OAAO,CAAC,EAChD,OAAO,CACP,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,wBAAwB,CAAC,aAAa,CAAE,SAAQ,SAAS,CAAC,aAAa,CAAC;IACxF,2HAA2H;IAC3H,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAuB,CAAC,aAAa,CAAE,SAAQ,SAAS,CAAC,aAAa,CAAC;IACvF,uGAAuG;IACvG,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,CAAC,aAAa,EAAE,aAAa,IAC5D,wBAAwB,CAAC,aAAa,CAAC,GACvC,uBAAuB,CAAC,aAAa,CAAC,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAC9B,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,GAChD,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;AAEnD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,wBAChB,SAAQ,UAAU,CAAC,+CAA+C,CAAC;CAAG;AAEvE;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,yBAA0B,SAAQ,wBAAwB;IAC1E;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAE/D;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,wBAAwB,CAAC;CAClD"}

package/lib/simple-tree/api/transactionTypes.js.map

@@ -1 +1 @@
-{"version":3,"file":"transactionTypes.js","sourceRoot":"","sources":["../../../src/simple-tree/api/transactionTypes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,iCAAiC,CAAC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { TreeNode } from \"../core/index.js\";\n\n/**\n * A special object that signifies when a SharedTree {@link RunTransaction | transaction} should \"roll back\".\n * @public\n */\nexport const rollback = Symbol(\"SharedTree Transaction Rollback\");\n\n/**\n * A requirement for a SharedTree transaction to succeed.\n * @remarks Transaction constraints are useful for validating that the state of the tree meets some requirement when a transaction runs.\n * In general, when running a transaction a client can validate their tree state in whatever way they wish and decide to either proceed with the transaction or not.\n * However, they cannot know what the tree state will be when the transaction is _sequenced_.\n * There may have been any number of edits from other clients that get sequenced before the transaction is eventually sequenced.\n * Constraints provide a way to validate the tree state after the transaction has been sequenced and abort the transaction if the constraints are not met.\n * All clients will validate the constraints of a transaction when it is sequenced, so all clients will agree on whether the transaction succeeds or not.\n * @public\n */\nexport type TransactionConstraint = NodeInDocumentConstraint; // TODO: Add more constraint types here\n\n/**\n * Type for alpha version {@link TransactionConstraint | constraint}s\n * @sealed @alpha\n */\nexport type TransactionConstraintAlpha = TransactionConstraint | NoChangeConstraint; // TODO: Add more constraint types here\n\n/**\n * A transaction {@link TransactionConstraint | constraint} which requires that the given node exists in the tree.\n * @remarks The node must be in the document (its {@link TreeStatus | status} must be {@link TreeStatus.InDocument | InDocument}) to qualify as \"existing\".\n * @public\n */\nexport interface NodeInDocumentConstraint {\n\treadonly type: \"nodeInDocument\";\n\treadonly node: TreeNode;\n}\n\n/**\n * A {@link TransactionConstraintAlpha | constraint} which requires that, for this transaction to apply, the document must be in the same state immediately before the transaction is applied as it was before the transaction was authored.\n * When used as a revert precondition it requires that, for the revert to apply, the document must be in the same state immediately before the revert is applied as it was after the transaction was applied.\n * @alpha\n */\nexport interface NoChangeConstraint {\n\treadonly type: \"noChange\";\n}\n\n/**\n * Contains a value returned from a transaction.\n * @alpha\n */\nexport interface WithValue<TValue> {\n\t/** The user-supplied value. */\n\tvalue: TValue;\n}\n\n/**\n * Contains a value and status returned from a user-supplied {@link TreeBranchAlpha.(runTransaction:1) | transaction callback}.\n * @alpha\n */\nexport type TransactionCallbackStatus<TSuccessValue, TFailureValue> = (\n\t| (WithValue<TSuccessValue> & {\n\t\t\t/** Indicates that the transaction callback ran successfully. */\n\t\t\trollback?: false;\n\t  })\n\t| (WithValue<TFailureValue> & {\n\t\t\t/** Indicates that the transaction callback failed and the transaction should be rolled back. */\n\t\t\trollback: true;\n\t  })\n) & {\n\t/**\n\t * An optional list of {@link TransactionConstraintAlpha | constraints} that will be checked when the commit corresponding\n\t * to this transaction is reverted. If any of these constraints are not met when the revert is being applied either\n\t * locally or on remote clients, the revert will be ignored.\n\t * These constraints must also be met at the time they are first introduced. If they are not met after the transaction\n\t * callback returns, then `runTransaction` (which invokes the transaction callback) will throw a `UsageError`.\n\t */\n\tpreconditionsOnRevert?: readonly TransactionConstraintAlpha[];\n};\n\n/**\n * The result of a {@link TreeBranchAlpha.(runTransaction:2) | transaction} that doesn't return a value.\n * @alpha\n */\nexport type VoidTransactionCallbackStatus = Omit<\n\tTransactionCallbackStatus<unknown, unknown>,\n\t\"value\"\n>;\n\n/**\n * The result of a {@link TreeBranchAlpha.(runTransaction:1) | transaction} that completed successfully.\n * @alpha\n */\nexport interface TransactionResultSuccess<TSuccessValue> extends WithValue<TSuccessValue> {\n\t/** The success flag for a transaction that completed without being {@link TransactionCallbackStatus | rolled back}. */\n\tsuccess: true;\n}\n\n/**\n * The result of a {@link TreeBranchAlpha.(runTransaction:1) | transaction} that was rolled back.\n * @alpha\n */\nexport interface TransactionResultFailed<TFailureValue> extends WithValue<TFailureValue> {\n\t/** The failure flag for a transaction that was {@link TransactionCallbackStatus | rolled back}. */\n\tsuccess: false;\n}\n\n/**\n * The result of the {@link RunTransaction | RunTransaction} API.\n * @alpha\n */\nexport type TransactionResultExt<TSuccessValue, TFailureValue> =\n\t| TransactionResultSuccess<TSuccessValue>\n\t| TransactionResultFailed<TFailureValue>;\n\n/**\n * The result of the {@link RunTransaction | RunTransaction} API. This is the same as {@link TransactionResultExt}\n * but with the `value` field omitted. This is useful when the transaction callback doesn't need to return a value.\n * @alpha\n */\nexport type TransactionResult =\n\t| Omit<TransactionResultSuccess<unknown>, \"value\">\n\t| Omit<TransactionResultFailed<unknown>, \"value\">;\n\n/**\n * The parameters for the {@link RunTransaction | RunTransaction} API.\n * @alpha\n * @input\n */\nexport interface RunTransactionParams {\n\t/**\n\t * An optional list of {@link TransactionConstraintAlpha | constraints} that are checked just before the transaction begins.\n\t * @remarks\n\t * If any of the constraints are not met when `runTransaction` is called, an error will be thrown.\n\t * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on this client and ignored by all other clients.\n\t */\n\treadonly preconditions?: readonly TransactionConstraintAlpha[];\n\t/**\n\t * A label for this transaction that allows it to be correlated with later edits (e.g. for controlling undo/redo grouping).\n\t * @remarks\n\t * If this transaction is applied to a {@link TreeBranchAlpha | branch}, the label will be available in the {@link LocalChangeMetadata.label | metadata} of the {@link TreeBranchEvents.changed | `changed`} event.\n\t *\n\t * If there is a nested transaction, only the outermost transaction label will be used.\n\t */\n\treadonly label?: unknown;\n}\n"]}
+{"version":3,"file":"transactionTypes.js","sourceRoot":"","sources":["../../../src/simple-tree/api/transactionTypes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,iCAAiC,CAAC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { ErasedType } from \"@fluidframework/core-interfaces\";\n\nimport type { TreeNode } from \"../core/index.js\";\n\n/**\n * A special object that signifies when a SharedTree {@link RunTransaction | transaction} should \"roll back\".\n * @public\n */\nexport const rollback = Symbol(\"SharedTree Transaction Rollback\");\n\n/**\n * A requirement for a SharedTree transaction to succeed.\n * @remarks Transaction constraints are useful for validating that the state of the tree meets some requirement when a transaction runs.\n * In general, when running a transaction a client can validate their tree state in whatever way they wish and decide to either proceed with the transaction or not.\n * However, they cannot know what the tree state will be when the transaction is _sequenced_.\n * There may have been any number of edits from other clients that get sequenced before the transaction is eventually sequenced.\n * Constraints provide a way to validate the tree state after the transaction has been sequenced and abort the transaction if the constraints are not met.\n * All clients will validate the constraints of a transaction when it is sequenced, so all clients will agree on whether the transaction succeeds or not.\n * @public\n */\nexport type TransactionConstraint = NodeInDocumentConstraint; // TODO: Add more constraint types here\n\n/**\n * Type for alpha version {@link TransactionConstraint | constraint}s\n * @sealed @alpha\n */\nexport type TransactionConstraintAlpha = TransactionConstraint | NoChangeConstraint; // TODO: Add more constraint types here\n\n/**\n * A transaction {@link TransactionConstraint | constraint} which requires that the given node exists in the tree.\n * @remarks The node must be in the document (its {@link TreeStatus | status} must be {@link TreeStatus.InDocument | InDocument}) to qualify as \"existing\".\n * @public\n */\nexport interface NodeInDocumentConstraint {\n\treadonly type: \"nodeInDocument\";\n\treadonly node: TreeNode;\n}\n\n/**\n * A {@link TransactionConstraintAlpha | constraint} which requires that, for this transaction to apply, the document must be in the same state immediately before the transaction is applied as it was before the transaction was authored.\n * When used as a revert precondition it requires that, for the revert to apply, the document must be in the same state immediately before the revert is applied as it was after the transaction was applied.\n * @alpha\n */\nexport interface NoChangeConstraint {\n\treadonly type: \"noChange\";\n}\n\n/**\n * Contains a value returned from a transaction.\n * @input\n * @beta\n */\nexport interface WithValue<TValue> {\n\t/** The user-supplied value. */\n\treadonly value: TValue;\n}\n\n/**\n * Contains a value and status returned from a user-supplied {@link TreeViewBeta.runTransaction | transaction callback}.\n * @input\n * @beta\n */\nexport type TransactionCallbackStatusBeta<TSuccessValue, TFailureValue> =\n\t| (WithValue<TSuccessValue> & {\n\t\t\t/** Indicates that the transaction callback ran successfully. */\n\t\t\treadonly rollback?: false;\n\t  })\n\t| (WithValue<TFailureValue> & {\n\t\t\t/** Indicates that the transaction callback failed and the transaction should be rolled back. */\n\t\t\treadonly rollback: true;\n\t  });\n\n/**\n * The result of a {@link TreeViewBeta.runTransaction | transaction} that doesn't return a value.\n * @input\n * @beta\n */\nexport type VoidTransactionCallbackStatusBeta = Omit<\n\tTransactionCallbackStatusBeta<unknown, unknown>,\n\t\"value\"\n>;\n\n/**\n * {@link TransactionCallbackStatusBeta} extended with alpha-only {@link TransactionConstraintAlpha | constraint} options.\n * @input\n * @alpha\n */\nexport type TransactionCallbackStatusAlpha<TSuccessValue, TFailureValue> =\n\tTransactionCallbackStatusBeta<TSuccessValue, TFailureValue> & {\n\t\t/**\n\t\t * An optional list of {@link TransactionConstraintAlpha | constraints} that will be checked when the commit corresponding\n\t\t * to this transaction is reverted. If any of these constraints are not met when the revert is being applied either\n\t\t * locally or on remote clients, the revert will be ignored.\n\t\t * These constraints must also be met at the time they are first introduced. If they are not met after the transaction\n\t\t * callback returns, then `runTransaction` (which invokes the transaction callback) will throw a `UsageError`.\n\t\t */\n\t\treadonly preconditionsOnRevert?: readonly TransactionConstraintAlpha[];\n\t};\n\n/**\n * The result of a {@link TreeBranchAlpha.(runTransaction:2) | transaction} that doesn't return a value.\n * @input\n * @alpha\n */\nexport type VoidTransactionCallbackStatusAlpha = Omit<\n\tTransactionCallbackStatusAlpha<unknown, unknown>,\n\t\"value\"\n>;\n\n/**\n * The result of a {@link TreeViewBeta.(runTransaction:1) | transaction} that completed successfully.\n * @sealed\n * @beta\n */\nexport interface TransactionResultSuccess<TSuccessValue> extends WithValue<TSuccessValue> {\n\t/** The success flag for a transaction that completed without being {@link TransactionCallbackStatusBeta | rolled back}. */\n\treadonly success: true;\n}\n\n/**\n * The result of a {@link TreeViewBeta.runTransaction | transaction} that was rolled back.\n * @sealed\n * @beta\n */\nexport interface TransactionResultFailed<TFailureValue> extends WithValue<TFailureValue> {\n\t/** The failure flag for a transaction that was {@link TransactionCallbackStatusBeta | rolled back}. */\n\treadonly success: false;\n}\n\n/**\n * The result of the {@link RunTransaction | RunTransaction} API.\n * @sealed\n * @beta\n */\nexport type TransactionValueResult<TSuccessValue, TFailureValue> =\n\t| TransactionResultSuccess<TSuccessValue>\n\t| TransactionResultFailed<TFailureValue>;\n\n/**\n * The result of the {@link RunTransaction | RunTransaction} API. This is the same as {@link TransactionValueResult}\n * but with the `value` field omitted. This is useful when the transaction callback doesn't need to return a value.\n * @sealed\n * @beta\n */\nexport type TransactionVoidResult =\n\t| Omit<TransactionResultSuccess<unknown>, \"value\">\n\t| Omit<TransactionResultFailed<unknown>, \"value\">;\n\n/**\n * A type-erased function that post-processes the change produced when a transaction is committed.\n *\n * @remarks\n * Supply one via {@link RunTransactionParamsAlpha.postProcessor} to process/alter\n * the change that a transaction produces. For example a post-processor could\n * remove extraneous information, so that the resulting squashed change contains\n * no extraneous information.\n *\n * This type intentionally hides its internal representation: its concrete shape\n * is an implementation detail of `@fluidframework/tree`. Obtain a value of this\n * type from a `@fluidframework/tree` helper or constant rather than constructing\n * one directly.\n *\n * @alpha\n * @sealed\n * @system\n */\nexport interface TransactionPostProcessor\n\textends ErasedType<\"@fluidframework/tree.TransactionPostProcessor\"> {}\n\n/**\n * The parameters for the {@link RunTransaction | RunTransaction} API.\n * @input\n * @beta\n */\nexport interface RunTransactionParamsBeta {\n\t/**\n\t * A label for this transaction that allows it to be correlated with later edits (e.g. for controlling undo/redo grouping).\n\t * @remarks\n\t * If this transaction is applied to a {@link TreeBranchAlpha | branch}, the label will be available in the {@link LocalChangeMetadata.label | metadata} of the {@link TreeBranchEvents.changed | `changed`} event.\n\t *\n\t * If there is a nested transaction, only the outermost transaction label will be used.\n\t */\n\treadonly label?: unknown;\n}\n\n/**\n * The parameters for the {@link RunTransaction | RunTransaction} API, extended with alpha-only {@link TransactionConstraintAlpha | constraint} options.\n * @input\n * @alpha\n */\nexport interface RunTransactionParamsAlpha extends RunTransactionParamsBeta {\n\t/**\n\t * An optional list of {@link TransactionConstraintAlpha | constraints} that are checked just before the transaction begins.\n\t * @remarks\n\t * If any of the constraints are not met when `runTransaction` is called, an error will be thrown.\n\t * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on this client and ignored by all other clients.\n\t */\n\treadonly preconditions?: readonly TransactionConstraintAlpha[];\n\n\t/**\n\t * An optional {@link TransactionPostProcessor | post-processor} applied to\n\t * the change produced when this transaction is committed.\n\t * @remarks\n\t * When omitted, the transaction's edits are squashed without any such processing.\n\t *\n\t * Specific post-processors are applied according to their own rules for\n\t * optimization and other post-processing tasks in a transaction stack. For\n\t * example a \"minimization\" post-processor may be applied once for the\n\t * outermost transaction in a stack as it will process all nested edits and\n\t * there is no benefit from multiple applications.\n\t *\n\t * Note: minimization is not yet implemented. Supplying a post-processor currently has no observable effect beyond\n\t * reserving the behavior; a real post-processor will be provided in a future change.\n\t */\n\treadonly postProcessor?: TransactionPostProcessor;\n}\n"]}

package/lib/simple-tree/api/tree.d.ts

@@ -9,7 +9,7 @@ import type { ImplicitFieldSchema, InsertableField, InsertableTreeFieldFromImpli
 import type { SimpleTreeSchema } from "../simpleSchema.js";
 import type { UnsafeUnknownSchema } from "../unsafeUnknownSchema.js";
 import type { TreeViewConfiguration } from "./configuration.js";
-import type { RunTransactionParams, TransactionCallbackStatus, TransactionResult, TransactionResultExt, VoidTransactionCallbackStatus, WithValue } from "./transactionTypes.js";
+import type { RunTransactionParamsAlpha, RunTransactionParamsBeta, TransactionCallbackStatusAlpha, TransactionCallbackStatusBeta, TransactionVoidResult, TransactionValueResult, VoidTransactionCallbackStatusAlpha, VoidTransactionCallbackStatusBeta, WithValue } from "./transactionTypes.js";
 import type { VerboseTree } from "./verboseTree.js";
 /**
  * A tree from which a {@link TreeView} can be created.
@@ -144,8 +144,8 @@ export interface TreeContextAlpha {
      * Run a synchronous transaction which groups sequential edits to the tree into a single atomic edit if possible.
      * @param transaction - A callback run during the transaction to perform user-supplied operations.
      * It may optionally return a {@link WithValue | value }, which will be returned by the `runTransaction` call.
-     * @param params - Optional {@link RunTransactionParams | parameters} for the transaction.
-     * @returns A {@link TransactionResultExt | value } indicating whether or not the transaction succeeded, and containing the value returned by `transaction`.
+     * @param params - Optional {@link RunTransactionParamsAlpha | parameters} for the transaction.
+     * @returns A {@link TransactionValueResult | value } indicating whether or not the transaction succeeded, and containing the value returned by `transaction`.
      * @remarks
      * All of the changes in the transaction are applied synchronously and therefore no other changes from a remote client can be interleaved with those changes.
      * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.
@@ -164,9 +164,15 @@ export interface TreeContextAlpha {
      * `runTransaction` may be invoked on the context of a {@link TreeStatus.InDocument | hydrated } or {@link Unhydrated | unhydrated } node.
      * Use {@link TreeContextAlpha.isBranch | isBranch() } to check whether this context is associated with a branch and gain {@link TreeBranchAlpha.(runTransaction:1) | access to more transaction capabilities} if so.
      */
-    runTransaction<TValue>(transaction: () => WithValue<TValue>, params?: RunTransactionParams): TransactionResultExt<TValue, TValue>;
-    /** An overload of {@link TreeContextAlpha.(runTransaction:1) | runTransaction } which does not return a value. */
-    runTransaction(transaction: () => void, params?: RunTransactionParams): TransactionResult;
+    runTransaction<TValue>(transaction: () => WithValue<TValue>, params?: RunTransactionParamsAlpha): TransactionValueResult<TValue, TValue>;
+    /**
+     * An overload of {@link TreeContextAlpha.(runTransaction:1) | runTransaction } which does not return a value.
+     *
+     * @privateRemarks
+     * TODO: Consider updating these methods to avoid the need for overloads.
+     * See {@link TreeViewBeta.runTransaction} for an example of how to do this.
+     */
+    runTransaction(transaction: () => void, params?: RunTransactionParamsAlpha): TransactionVoidResult;
     /**
      * An asynchronous version of {@link TreeContextAlpha.(runTransaction:1) | runTransaction}.
      * @remarks
@@ -178,9 +184,15 @@ export interface TreeContextAlpha {
      *
      * An asynchronous transaction may not be started while any other transaction is in progress in this context.
      */
-    runTransactionAsync<TValue>(transaction: () => Promise<WithValue<TValue>>, params?: RunTransactionParams): Promise<TransactionResultExt<TValue, TValue>>;
-    /** An overload of {@link TreeContextAlpha.(runTransactionAsync:1) | runTransactionAsync } which does not return a value. */
-    runTransactionAsync(transaction: () => Promise<void>, params?: RunTransactionParams): Promise<TransactionResult>;
+    runTransactionAsync<TValue>(transaction: () => Promise<WithValue<TValue>>, params?: RunTransactionParamsAlpha): Promise<TransactionValueResult<TValue, TValue>>;
+    /**
+     * An overload of {@link TreeContextAlpha.(runTransactionAsync:1) | runTransactionAsync } which does not return a value.
+     *
+     * @privateRemarks
+     * TODO: Consider updating these methods to avoid the need for overloads.
+     * See {@link TreeViewBeta.runTransactionAsync} for an example of how to do this.
+     */
+    runTransactionAsync(transaction: () => Promise<void>, params?: RunTransactionParamsAlpha): Promise<TransactionVoidResult>;
     /**
      * True if this context is associated with a {@link TreeBranchAlpha | branch} and false if it is associated with an {@link Unhydrated | unhydrated } node.
      * @remarks If this returns true, the context can be safely inferred or cast to {@link TreeBranchAlpha} to access additional branch-specific APIs.
@@ -226,24 +238,32 @@ export interface TreeBranchAlpha extends TreeBranch, TreeContextAlpha {
     fork(): TreeBranchAlpha;
     /**
      * {@link TreeContextAlpha.(runTransaction:1) | Run a transaction} on a branch of the SharedTree.
-     * @param transaction - The function to run as the body of the transaction, which may optionally return a {@link TransactionCallbackStatus | value or rollback signal}.
+     * @param transaction - The function to run as the body of the transaction, which may optionally return a {@link TransactionCallbackStatusAlpha | value or rollback signal}.
      * @remarks
      * If the transaction is rolled back, a corresponding {@link TreeBranchEvents.changed | `changed`} event will also be emitted for the rollback.
      */
-    runTransaction<TSuccessValue, TFailureValue>(transaction: () => TransactionCallbackStatus<TSuccessValue, TFailureValue>, params?: RunTransactionParams): TransactionResultExt<TSuccessValue, TFailureValue>;
+    runTransaction<TSuccessValue, TFailureValue>(transaction: () => TransactionCallbackStatusAlpha<TSuccessValue, TFailureValue>, params?: RunTransactionParamsAlpha): TransactionValueResult<TSuccessValue, TFailureValue>;
     /**
      * An overload of {@link TreeBranchAlpha.(runTransaction:1) | runTransaction } which does not return a value.
+     *
+     * @privateRemarks
+     * TODO: Consider updating these methods to avoid the need for overloads.
+     * See {@link TreeViewBeta.runTransaction} for an example of how to do this.
      */
-    runTransaction(transaction: () => VoidTransactionCallbackStatus | void, params?: RunTransactionParams): TransactionResult;
+    runTransaction(transaction: () => VoidTransactionCallbackStatusAlpha | void, params?: RunTransactionParamsAlpha): TransactionVoidResult;
     /**
      * An asynchronous version of {@link TreeBranchAlpha.(runTransaction:1) | runTransaction}.
      * @remarks See {@link TreeContextAlpha.(runTransactionAsync:1) | runTransactionAsync} for additional information about asynchronous transactions.
      */
-    runTransactionAsync<TSuccessValue, TFailureValue>(transaction: () => Promise<TransactionCallbackStatus<TSuccessValue, TFailureValue>>, params?: RunTransactionParams): Promise<TransactionResultExt<TSuccessValue, TFailureValue>>;
+    runTransactionAsync<TSuccessValue, TFailureValue>(transaction: () => Promise<TransactionCallbackStatusAlpha<TSuccessValue, TFailureValue>>, params?: RunTransactionParamsAlpha): Promise<TransactionValueResult<TSuccessValue, TFailureValue>>;
     /**
      * An overload of {@link TreeBranchAlpha.(runTransactionAsync:1) | runTransactionAsync } which does not return a value.
+     *
+     * @privateRemarks
+     * TODO: Consider updating these methods to avoid the need for overloads.
+     * See {@link TreeViewBeta.runTransactionAsync} for an example of how to do this.
      */
-    runTransactionAsync(transaction: () => Promise<VoidTransactionCallbackStatus | void>, params?: RunTransactionParams): Promise<TransactionResult>;
+    runTransactionAsync(transaction: () => Promise<VoidTransactionCallbackStatusAlpha | void>, params?: RunTransactionParamsAlpha): Promise<TransactionVoidResult>;
     /**
      * Apply a serialized change to this branch.
      * @param change - the change to apply.
@@ -354,30 +374,74 @@ export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends ID
      */
     readonly schema: TSchema;
 }
+/**
+ * {@link TreeView} with additional beta APIs.
+ * @sealed @beta
+ */
+export interface TreeViewBeta<in out TSchema extends ImplicitFieldSchema> extends TreeView<TSchema>, TreeBranch {
+    fork(): ReturnType<TreeBranch["fork"]> & TreeViewBeta<TSchema>;
+    /**
+     * Run a synchronous transaction which groups sequential edits to the tree into a single atomic edit if possible.
+     *
+     * @param transaction - The function to run as the body of the transaction, which may optionally return a {@link TransactionCallbackStatusBeta | value or rollback signal}.
+     * It may optionally return a {@link WithValue | value }, which will be returned by the `runTransaction` call.
+     *
+     * @param params - Optional {@link RunTransactionParamsBeta | parameters} for the transaction.
+     *
+     * @returns A {@link TransactionValueResult | value } indicating whether or not the transaction succeeded, and containing the value returned by `transaction`.
+     *
+     * @remarks
+     * All of the changes in the transaction are applied synchronously and therefore no other changes from a remote client can be interleaved with those changes.
+     * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.
+     *
+     * {@link (TreeBeta:interface).on | Change events } will be emitted for changed nodes on this client _as each edit happens_, just as they would be if the changes were made outside of a transaction.
+     * Any other/future clients or contexts will process the transaction "squashed", i.e. they will apply its changes all at once, emitting only a single event per node (even if that node was edited multiple times in the transaction).
+     * Edits to the tree are not permitted within these event callbacks, therefore no other local changes from this client will be interleaved with the changes in this transaction.
+     *
+     * Using a transaction has the following additional consequences:
+     *
+     * - If {@link Revertible | reverted } (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+     * Only the "outermost" transaction commits a change to the synchronized tree state and therefore only the outermost transaction can be reverted.
+     * If a transaction is started and completed while another transaction is already in progress, then the inner transaction will be reverted together with the outer transaction.
+     * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
+     *
+     * If the transaction is rolled back, a corresponding {@link TreeBranchEvents.changed | `changed`} event will also be emitted for the rollback.
+     */
+    runTransaction<TOut extends TransactionCallbackStatusBeta<unknown, unknown> | VoidTransactionCallbackStatusBeta | void>(transaction: () => TOut, params?: RunTransactionParamsBeta): TOut extends TransactionCallbackStatusBeta<infer TSuccessValue, infer TFailureValue> ? TransactionValueResult<TSuccessValue, TFailureValue> : TransactionVoidResult;
+    /**
+     * An asynchronous version of {@link TreeViewBeta.runTransaction | runTransaction}.
+     *
+     * @remarks
+     * As with synchronous transactions, all of the changes in an asynchronous transaction are treated as a unit.
+     * Therefore, no other changes (either from this client or from a remote client) can be interleaved with the transaction changes.
+     *
+     * Unlike with synchronous transactions, it is possible that other changes (e.g. from a remote client) may be applied to the branch while this transaction is in progress.
+     * Those other changes will be not be reflected on the branch until after this transaction completes, at which point the transaction changes will be applied after those other changes.
+     *
+     * An asynchronous transaction may not be started while any other transaction is in progress in this view.
+     */
+    runTransactionAsync<TOut extends TransactionCallbackStatusBeta<unknown, unknown> | VoidTransactionCallbackStatusBeta | void>(transaction: () => Promise<TOut>, params?: RunTransactionParamsBeta): Promise<TOut extends TransactionCallbackStatusBeta<infer TSuccessValue, infer TFailureValue> ? TransactionValueResult<TSuccessValue, TFailureValue> : TransactionVoidResult>;
+}
 /**
  * {@link TreeView} with proposed changes to the schema aware typing to allow use with `UnsafeUnknownSchema`.
  * @sealed @alpha
  */
-export interface TreeViewAlpha<in out TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> extends Omit<TreeViewBeta<ReadSchema<TSchema>>, "root" | "initialize" | "fork">, TreeBranchAlpha {
+export interface TreeViewAlpha<in out TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> extends Omit<TreeViewBeta<ReadSchema<TSchema>>, "root" | "initialize" | "fork" | "runTransaction" | "runTransactionAsync">, TreeBranchAlpha {
     get root(): ReadableField<TSchema>;
     set root(newRoot: InsertableField<TSchema>);
     initialize(content: InsertableField<TSchema>): void;
     readonly events: Listenable<TreeViewEvents & TreeBranchEvents>;
     fork(): ReturnType<TreeBranch["fork"]> & TreeViewAlpha<TSchema>;
 }
-/**
- * {@link TreeView} with additional beta APIs.
- * @sealed @beta
- */
-export interface TreeViewBeta<in out TSchema extends ImplicitFieldSchema> extends TreeView<TSchema>, TreeBranch {
-    fork(): ReturnType<TreeBranch["fork"]> & TreeViewBeta<TSchema>;
-}
 /**
  * Information about a view schema's compatibility with the document's stored schema.
  *
+ * @see
  * See SharedTree's README for more information about choosing a compatibility policy.
+ *
  * @privateRemarks
  * See {@link SchemaCompatibilityTester} for the implementation of this compatibility checking.
+ *
  * @sealed @public
  */
 export interface SchemaCompatibilityStatus {

package/lib/simple-tree/api/tree.d.ts.map

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