@fluidframework/tree 2.33.2 → 2.40.0

package/dist/shared-tree/{treeApi.d.ts → tree.d.ts}

@@ -3,6 +3,39 @@
  * Licensed under the MIT License.
  */
 import { type ImplicitFieldSchema, type TreeNode, type TreeNodeApi, type TreeView, rollback, type TransactionConstraint } from "../simple-tree/index.js";
+/**
+ * Provides various functions for interacting with {@link TreeNode}s.
+ * @remarks
+ * This type should only be used via the {@link (Tree:variable)} export.
+ * @system @sealed @public
+ */
+export interface Tree extends TreeNodeApi {
+    /**
+     * Run a {@link RunTransaction | transaction}.
+     */
+    readonly runTransaction: RunTransaction;
+    /**
+     * Check if the subtree defined by `node` contains `other`.
+     *
+     * @returns true if `other` is an inclusive descendant of `node`, and false otherwise.
+     * @remarks
+     * This includes direct and indirect children:
+     * as long as `node` is an ancestor of `other` (occurs in its parentage chain), this returns true, regardless of the number of levels of the tree between.
+     *
+     * `node` is considered to contain itself, so the case where `node === other` returns true.
+     *
+     * This is handy when checking if moving `node` into `other` would create a cycle and would thus be invalid.
+     *
+     * This check walks the parents of `other` looking for `node`,
+     * and thus runs in time proportional to the depth of child in the tree.
+     */
+    contains(node: TreeNode, other: TreeNode): boolean;
+}
+/**
+ * The {@link (Tree:interface)} singleton which holds various functions for interacting with {@link TreeNode}s.
+ * @public
+ */
+export declare const Tree: Tree;
 /**
  * A function which runs a transaction in a SharedTree.
  * @privateRemarks
@@ -26,7 +59,9 @@ export interface RunTransaction {
      * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or 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.
      * However, using a transaction has the following additional consequences:
+     *
      * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+     *
      * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
      *
      * Local change events will be emitted for each change as the transaction is being applied.
@@ -44,7 +79,9 @@ export interface RunTransaction {
      * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or 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.
      * However, using a transaction has the following additional consequences:
+     *
      * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+     *
      * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
      *
      * Local change events will be emitted for each change as the transaction is being applied.
@@ -64,7 +101,9 @@ export interface RunTransaction {
      * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or 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.
      * However, using a transaction has the following additional consequences:
+     *
      * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+     *
      * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
      *
      * Local change events will be emitted for each change as the transaction is being applied.
@@ -83,7 +122,9 @@ export interface RunTransaction {
      * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or 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.
      * However, using a transaction has the following additional consequences:
+     *
      * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+     *
      * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
      *
      * Local change events will be emitted for each change as the transaction is being applied.
@@ -101,7 +142,9 @@ export interface RunTransaction {
      * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or 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.
      * However, using a transaction has the following additional consequences:
+     *
      * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+     *
      * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
      *
      * Local change events will be emitted for each change as the transaction is being applied.
@@ -118,7 +161,9 @@ export interface RunTransaction {
      * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or 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.
      * However, using a transaction has the following additional consequences:
+     *
      * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+     *
      * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
      *
      * Local change events will be emitted for each change as the transaction is being applied.
@@ -140,7 +185,9 @@ export interface RunTransaction {
      * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or 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.
      * However, using a transaction has the following additional consequences:
+     *
      * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+     *
      * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
      *
      * Local change events will be emitted for each change as the transaction is being applied.
@@ -161,7 +208,9 @@ export interface RunTransaction {
      * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or 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.
      * However, using a transaction has the following additional consequences:
+     *
      * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+     *
      * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
      *
      * Local change events will be emitted for each change as the transaction is being applied.
@@ -184,7 +233,9 @@ export interface RunTransaction {
      * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or 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.
      * However, using a transaction has the following additional consequences:
+     *
      * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+     *
      * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
      *
      * Local change events will be emitted for each change as the transaction is being applied.
@@ -206,7 +257,9 @@ export interface RunTransaction {
      * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or 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.
      * However, using a transaction has the following additional consequences:
+     *
      * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+     *
      * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
      *
      * Local change events will be emitted for each change as the transaction is being applied.
@@ -227,7 +280,9 @@ export interface RunTransaction {
      * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or 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.
      * However, using a transaction has the following additional consequences:
+     *
      * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+     *
      * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
      *
      * Local change events will be emitted for each change as the transaction is being applied.
@@ -247,7 +302,9 @@ export interface RunTransaction {
      * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or 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.
      * However, using a transaction has the following additional consequences:
+     *
      * - If reverted (e.g. via an "undo" operation), all the changes in the transaction are reverted together.
+     *
      * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.
      *
      * Local change events will be emitted for each change as the transaction is being applied.
@@ -256,39 +313,6 @@ export interface RunTransaction {
      */
     <TView extends TreeView<any>>(tree: TView, transaction: (root: TView["root"]) => void, preconditions?: readonly TransactionConstraint[]): void;
 }
-/**
- * Provides various functions for interacting with {@link TreeNode}s.
- * @remarks
- * This type should only be used via the public `Tree` export.
- * @system @sealed @public
- */
-export interface TreeApi extends TreeNodeApi {
-    /**
-     * Run a {@link RunTransaction | transaction}.
-     */
-    readonly runTransaction: RunTransaction;
-    /**
-     * Check if the subtree defined by `node` contains `other`.
-     *
-     * @returns true if `other` is an inclusive descendant of `node`, and false otherwise.
-     * @remarks
-     * This includes direct and indirect children:
-     * as long as `node` is an ancestor of `other` (occurs in its parentage chain), this returns true, regardless of the number of levels of the tree between.
-     *
-     * `node` is considered to contain itself, so the case where `node === other` returns true.
-     *
-     * This is handy when checking if moving `node` into `other` would create a cycle and thus is invalid.
-     *
-     * This check walks the parents of `other` looking for `node`,
-     * and thus runs in time proportional to the depth of child in the tree.
-     */
-    contains(node: TreeNode, other: TreeNode): boolean;
-}
-/**
- * The `Tree` object holds various functions for interacting with {@link TreeNode}s.
- * @public
- */
-export declare const treeApi: TreeApi;
 /**
  * Run the given transaction.
  * @remarks
@@ -296,4 +320,4 @@ export declare const treeApi: TreeApi;
  * @deprecated This API catches exceptions then tries to modify the tree before rethrowing: this is not robust. Use {@link TreeViewAlpha.runTransaction} instead which does not try to edit content in the error case.
  */
 export declare function runTransaction<TNode extends TreeNode, TRoot extends ImplicitFieldSchema, TResult>(treeOrNode: TNode | TreeView<TRoot>, transaction: ((node: TNode) => TResult | typeof rollback) | ((root: TRoot) => TResult | typeof rollback), preconditions?: readonly TransactionConstraint[]): TResult | typeof rollback;
-//# sourceMappingURL=treeApi.d.ts.map
+//# sourceMappingURL=tree.d.ts.map

package/dist/shared-tree/tree.d.ts.map

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

package/dist/shared-tree/{treeApi.js → tree.js}

@@ -4,7 +4,7 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runTransaction = exports.treeApi = void 0;
+exports.runTransaction = exports.Tree = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/telemetry-utils/internal");
 const index_js_1 = require("../feature-libraries/index.js");
@@ -12,10 +12,10 @@ const index_js_2 = require("../simple-tree/index.js");
 const schematizingTreeView_js_1 = require("./schematizingTreeView.js");
 const checkoutFlexTreeView_js_1 = require("./checkoutFlexTreeView.js");
 /**
- * The `Tree` object holds various functions for interacting with {@link TreeNode}s.
+ * The {@link (Tree:interface)} singleton which holds various functions for interacting with {@link TreeNode}s.
  * @public
  */
-exports.treeApi = {
+exports.Tree = {
     ...index_js_2.treeNodeApi,
     runTransaction: createRunTransaction(),
     contains(parent, child) {
@@ -24,7 +24,7 @@ exports.treeApi = {
             if (toCheck === parent) {
                 return true;
             }
-            toCheck = exports.treeApi.parent(toCheck);
+            toCheck = exports.Tree.parent(toCheck);
         }
         return false;
     },
@@ -72,7 +72,7 @@ function runTransactionInCheckout(checkout, transaction, preconditions) {
         switch (constraint.type) {
             case "nodeInDocument": {
                 const node = (0, index_js_2.getOrCreateInnerNode)(constraint.node);
-                const nodeStatus = exports.treeApi.status(constraint.node);
+                const nodeStatus = exports.Tree.status(constraint.node);
                 if (nodeStatus !== index_js_1.TreeStatus.InDocument) {
                     throw new internal_2.UsageError(`Attempted to add a "nodeInDocument" constraint, but the node is not currently in the document. Node status: ${nodeStatus}`);
                 }
@@ -102,4 +102,4 @@ function runTransactionInCheckout(checkout, transaction, preconditions) {
     }
     return result;
 }
-//# sourceMappingURL=treeApi.js.map
+//# sourceMappingURL=tree.js.map

package/dist/shared-tree/tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.js","sourceRoot":"","sources":["../../src/shared-tree/tree.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 { unreachableCase } from \"@fluidframework/core-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport { TreeStatus } from \"../feature-libraries/index.js\";\nimport {\n\ttype ImplicitFieldSchema,\n\ttype TreeNode,\n\ttype TreeNodeApi,\n\ttype TreeView,\n\tgetOrCreateInnerNode,\n\ttreeNodeApi,\n\trollback,\n\ttype TransactionConstraint,\n} from \"../simple-tree/index.js\";\n\nimport { SchematizingSimpleTreeView } from \"./schematizingTreeView.js\";\nimport type { ITreeCheckout } from \"./treeCheckout.js\";\nimport { getCheckoutFlexTreeView } from \"./checkoutFlexTreeView.js\";\n\n/**\n * Provides various functions for interacting with {@link TreeNode}s.\n * @remarks\n * This type should only be used via the {@link (Tree:variable)} export.\n * @system @sealed @public\n */\nexport interface Tree extends TreeNodeApi {\n\t/**\n\t * Run a {@link RunTransaction | transaction}.\n\t */\n\treadonly runTransaction: RunTransaction;\n\t/**\n\t * Check if the subtree defined by `node` contains `other`.\n\t *\n\t * @returns true if `other` is an inclusive descendant of `node`, and false otherwise.\n\t * @remarks\n\t * This includes direct and indirect children:\n\t * as long as `node` is an ancestor of `other` (occurs in its parentage chain), this returns true, regardless of the number of levels of the tree between.\n\t *\n\t * `node` is considered to contain itself, so the case where `node === other` returns true.\n\t *\n\t * This is handy when checking if moving `node` into `other` would create a cycle and would thus be invalid.\n\t *\n\t * This check walks the parents of `other` looking for `node`,\n\t * and thus runs in time proportional to the depth of child in the tree.\n\t */\n\tcontains(node: TreeNode, other: TreeNode): boolean;\n}\n\n/**\n * The {@link (Tree:interface)} singleton which holds various functions for interacting with {@link TreeNode}s.\n * @public\n */\nexport const Tree: Tree = {\n\t...treeNodeApi,\n\n\trunTransaction: createRunTransaction(),\n\n\tcontains(parent: TreeNode, child: TreeNode): boolean {\n\t\tlet toCheck: TreeNode | undefined = child;\n\t\twhile (toCheck !== undefined) {\n\t\t\tif (toCheck === parent) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\ttoCheck = Tree.parent(toCheck);\n\t\t}\n\t\treturn false;\n\t},\n};\n\n/**\n * A function which runs a transaction in a SharedTree.\n * @privateRemarks\n * This interface exists so that the (generously) overloaded `Tree.runTransaction` function can have the \"rollback\" property hanging off of it.\n * The rollback property being available on the function itself gives users a convenient option for rolling back a transaction without having to import another symbol.\n * @sealed @public\n */\nexport interface RunTransaction {\n\t/**\n\t * The {@link rollback} object used to roll back a transaction.\n\t */\n\treadonly rollback: typeof rollback;\n\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode, TResult>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => TResult,\n\t): TResult;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t// TODO: TreeView is invariant over the schema, so to accept any view, `any` is the only real option unless a non generic (or covariant) base type for view is introduced (which is planned).\n\t// This use of any is actually type safe as it is only used as a constraint, and the actual strongly typed view (TView) is passed to the callback.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>, TResult>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => TResult,\n\t): TResult;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * At any point during the transaction, the function may return the special {@link RunTransaction.rollback | rollback value} (`Tree.runTransaction.rollback`) to abort the transaction and discard any changes it made so far.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode, TResult>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => TResult | typeof rollback,\n\t): TResult | typeof rollback;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * At any point during the transaction, the function may return the special {@link RunTransaction.rollback | rollback value} (`Tree.runTransaction.rollback`) to abort the transaction and discard any changes it made so far.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>, TResult>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => TResult | typeof rollback,\n\t): TResult | typeof rollback;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void): void;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>>(tree: TView, transaction: (root: TView[\"root\"]) => void): void;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\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 * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode, TResult>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => TResult,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): TResult;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\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 * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>, TResult>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => TResult,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): TResult;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * At any point during the transaction, the function may return the special {@link RunTransaction.rollback | rollback value} (`Tree.runTransaction.rollback`) to abort the transaction and discard any changes it made so far.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\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 * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode, TResult>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => TResult | typeof rollback,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): TResult | typeof rollback;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * At any point during the transaction, the function may return the special {@link RunTransaction.rollback | rollback value} (`Tree.runTransaction.rollback`) to abort the transaction and discard any changes it made so far.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\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 * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>, TResult>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => TResult | typeof rollback,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): TResult | typeof rollback;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\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 * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => void,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): void;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\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 * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => void,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): void;\n}\n\n// TODO: Add more constraint types here\n\n/** Creates a copy of `runTransaction` with the `rollback` property added so as to satisfy the `RunTransaction` interface. */\nfunction createRunTransaction(): RunTransaction {\n\t/** A type-safe helper to add a \"rollback\" property (as required by the `RunTransaction` interface) to a given object */\n\tfunction defineRollbackProperty<T extends object>(\n\t\ttarget: T,\n\t): T & { rollback: typeof rollback } {\n\t\tReflect.defineProperty(target, \"rollback\", { value: rollback });\n\t\treturn target as T & { readonly rollback: typeof rollback };\n\t}\n\n\treturn defineRollbackProperty(runTransaction.bind({}));\n}\n\n/**\n * Run the given transaction.\n * @remarks\n * This API is not publicly exported but is exported outside of this module so that test code may unit test the `Tree.runTransaction` function directly without being restricted to its public API overloads.\n * @deprecated This API catches exceptions then tries to modify the tree before rethrowing: this is not robust. Use {@link TreeViewAlpha.runTransaction} instead which does not try to edit content in the error case.\n */\nexport function runTransaction<\n\tTNode extends TreeNode,\n\tTRoot extends ImplicitFieldSchema,\n\tTResult,\n>(\n\ttreeOrNode: TNode | TreeView<TRoot>,\n\ttransaction:\n\t\t| ((node: TNode) => TResult | typeof rollback)\n\t\t| ((root: TRoot) => TResult | typeof rollback),\n\tpreconditions: readonly TransactionConstraint[] = [],\n): TResult | typeof rollback {\n\tif (treeOrNode instanceof SchematizingSimpleTreeView) {\n\t\tconst t = transaction as (root: TRoot) => TResult | typeof rollback;\n\t\treturn runTransactionInCheckout(\n\t\t\ttreeOrNode.checkout,\n\t\t\t() => t(treeOrNode.root as TRoot),\n\t\t\tpreconditions,\n\t\t);\n\t} else {\n\t\tconst node = treeOrNode as TNode;\n\t\tconst t = transaction as (node: TNode) => TResult | typeof rollback;\n\t\tconst context = getOrCreateInnerNode(node).context;\n\t\tif (context.isHydrated() === false) {\n\t\t\tthrow new UsageError(\n\t\t\t\t\"Transactions cannot be run on Unhydrated nodes. Transactions apply to a TreeView and Unhydrated nodes are not part of a TreeView.\",\n\t\t\t);\n\t\t}\n\t\tconst treeView = getCheckoutFlexTreeView(context);\n\t\treturn runTransactionInCheckout(treeView.checkout, () => t(node), preconditions);\n\t}\n}\n\n/**\n * Run the given transaction.\n * @deprecated This API catches exceptions then tries to modify the tree before rethrowing: this is not robust. Use {@link TreeViewAlpha.runTransaction} instead which does not try to editing content in the error case.\n */\nfunction runTransactionInCheckout<TResult>(\n\tcheckout: ITreeCheckout,\n\ttransaction: () => TResult | typeof rollback,\n\tpreconditions: readonly TransactionConstraint[],\n): TResult | typeof rollback {\n\tcheckout.transaction.start();\n\tfor (const constraint of preconditions) {\n\t\tswitch (constraint.type) {\n\t\t\tcase \"nodeInDocument\": {\n\t\t\t\tconst node = getOrCreateInnerNode(constraint.node);\n\t\t\t\tconst nodeStatus = Tree.status(constraint.node);\n\t\t\t\tif (nodeStatus !== TreeStatus.InDocument) {\n\t\t\t\t\tthrow new UsageError(\n\t\t\t\t\t\t`Attempted to add a \"nodeInDocument\" constraint, but the node is not currently in the document. Node status: ${nodeStatus}`,\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\tcheckout.editor.addNodeExistsConstraint(node.anchorNode);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tdefault:\n\t\t\t\tunreachableCase(constraint.type);\n\t\t}\n\t}\n\n\tlet result: ReturnType<typeof transaction>;\n\ttry {\n\t\tresult = transaction();\n\t} catch (error) {\n\t\t// If the transaction has an unhandled error, abort and rollback the transaction but continue to propagate the error.\n\t\t// This might try and modify the tree or trigger events while things are in an inconsistent state.\n\t\t// It is up to the user of runTransaction to ensure that does not cause problems (and they have no robust way to do that, which is why its deprecated).\n\t\tcheckout.transaction.abort();\n\t\tthrow error;\n\t}\n\n\tif (result === rollback) {\n\t\tcheckout.transaction.abort();\n\t} else {\n\t\tcheckout.transaction.commit();\n\t}\n\n\treturn result;\n}\n"]}

package/{lib/shared-tree/treeApiAlpha.d.ts → dist/shared-tree/treeAlpha.d.ts}

@@ -8,10 +8,12 @@ import { type TreeNode, type Unhydrated, type ImplicitFieldSchema, type Insertab
 import type { JsonCompatible } from "../util/index.js";
 import { type FluidClientVersion, type ICodecOptions } from "../codec/index.js";
 /**
- * Extensions to {@link Tree} and {@link TreeBeta} which are not yet stable.
- * @sealed @alpha
+ * Extensions to {@link (Tree:interface)} and {@link (TreeBeta:interface)} which are not yet stable.
+ * @remarks
+ * Use via the {@link (TreeAlpha:variable)} singleton.
+ * @system @sealed @alpha
  */
-export declare const TreeAlpha: {
+export interface TreeAlpha {
     /**
      * Retrieve the {@link TreeBranch | branch}, if any, for the given node.
      * @param node - The node to query
@@ -32,13 +34,13 @@ export declare const TreeAlpha: {
      * such as when `undefined` might be allowed (for an optional field), or when the type should be inferred from the data when more than one type is possible.
      *
      * Like with {@link TreeNodeSchemaClass}'s constructor, it's an error to provide an existing node to this API.
-     * For that case, use {@link TreeBeta.clone}.
+     * For that case, use {@link (TreeBeta:interface).clone}.
      * @privateRemarks
      * There should be a way to provide a source for defaulted identifiers, wither via this API or some way to add them to its output later.
      */
     create<const TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema>(schema: UnsafeUnknownSchema extends TSchema ? ImplicitFieldSchema : TSchema & ImplicitFieldSchema, data: InsertableField<TSchema>): Unhydrated<TSchema extends ImplicitFieldSchema ? TreeFieldFromImplicitField<TSchema> : TreeNode | TreeLeafValue | undefined>;
     /**
-     * Less type safe version of {@link TreeAlpha.create}, suitable for importing data.
+     * Less type safe version of {@link (TreeAlpha:interface).create}, suitable for importing data.
      * @remarks
      * Due to {@link ConciseTree} relying on type inference from the data, its use is somewhat limited.
      * This does not support {@link ConciseTree|ConciseTrees} with customized handle encodings or using persisted keys.
@@ -46,8 +48,8 @@ export declare const TreeAlpha: {
      *
      * When using this function,
      * it is recommend to ensure your schema is unambiguous with {@link ITreeConfigurationOptions.preventAmbiguity}.
-     * If the schema is ambiguous, consider using {@link TreeAlpha.create} and {@link Unhydrated} nodes where needed,
-     * or using {@link TreeAlpha.(importVerbose:1)} and specify all types.
+     * If the schema is ambiguous, consider using {@link (TreeAlpha:interface).create} and {@link Unhydrated} nodes where needed,
+     * or using {@link (TreeAlpha:interface).(importVerbose:1)} and specify all types.
      *
      * Documented (and thus recoverable) error handling/reporting for this is not yet implemented,
      * but for now most invalid inputs will throw a recoverable error.
@@ -56,7 +58,7 @@ export declare const TreeAlpha: {
     /**
      * Construct tree content compatible with a field defined by the provided `schema`.
      * @param schema - The schema for what to construct. As this is an {@link ImplicitFieldSchema}, a {@link FieldSchema}, {@link TreeNodeSchema} or {@link AllowedTypes} array can be provided.
-     * @param data - The data used to construct the field content. See {@link TreeAlpha.(exportVerbose:1)}.
+     * @param data - The data used to construct the field content. See {@link (TreeAlpha:interface).(exportVerbose:1)}.
      */
     importVerbose<const TSchema extends ImplicitFieldSchema>(schema: TSchema, data: VerboseTree | undefined, options?: Partial<TreeEncodingOptions>): Unhydrated<TreeFieldFromImplicitField<TSchema>>;
     /**
@@ -72,7 +74,7 @@ export declare const TreeAlpha: {
      * Uses the {@link VerboseTree} format, with an explicit type on every node.
      *
      * @remarks
-     * There are several cases this may be preferred to {@link TreeAlpha.(exportConcise:1)}:
+     * There are several cases this may be preferred to {@link (TreeAlpha:interface).(exportConcise:1)}:
      *
      * 1. When not using {@link ITreeConfigurationOptions.preventAmbiguity} (or when using `useStableFieldKeys`), `exportConcise` can produce ambiguous data (the type may be unclear on some nodes).
      * `exportVerbose` will always be unambiguous and thus lossless.
@@ -103,11 +105,11 @@ export declare const TreeAlpha: {
         idCompressor?: IIdCompressor;
     }): JsonCompatible<IFluidHandle>;
     /**
-     * Import data encoded by {@link TreeAlpha.exportCompressed}.
+     * Import data encoded by {@link (TreeAlpha:interface).exportCompressed}.
      *
      * @param schema - Schema with which the data must be compatible. This compatibility is not verified and must be ensured by the caller.
-     * @param compressedData - Data compressed by {@link TreeAlpha.exportCompressed}.
-     * @param options - If {@link TreeAlpha.exportCompressed} was given an `idCompressor`, it must be provided here.
+     * @param compressedData - Data compressed by {@link (TreeAlpha:interface).exportCompressed}.
+     * @param options - If {@link (TreeAlpha:interface).exportCompressed} was given an `idCompressor`, it must be provided here.
      *
      * @remarks
      * If the data could have been encoded with a different schema, consider encoding the schema along side it using {@link extractPersistedSchema} and loading the data using {@link independentView}.
@@ -116,11 +118,19 @@ export declare const TreeAlpha: {
      * This API could be improved:
      *
      * 1. It could validate that the schema is compatible, and return or throw an error in the invalid case (maybe add a "try" version).
+     *
      * 2. A "try" version of this could return an error if the data isn't in a supported format (as determined by version and/or JasonValidator).
+     *
      * 3. Requiring the caller provide a JsonValidator isn't the most friendly API. It might be practical to provide a default.
      */
     importCompressed<const TSchema extends ImplicitFieldSchema>(schema: TSchema, compressedData: JsonCompatible<IFluidHandle>, options: {
         idCompressor?: IIdCompressor;
     } & ICodecOptions): Unhydrated<TreeFieldFromImplicitField<TSchema>>;
-};
-//# sourceMappingURL=treeApiAlpha.d.ts.map
+}
+/**
+ * Extensions to {@link (Tree:variable)} and {@link (TreeBeta:variable)} which are not yet stable.
+ * @see {@link (TreeAlpha:interface)}.
+ * @alpha
+ */
+export declare const TreeAlpha: TreeAlpha;
+//# sourceMappingURL=treeAlpha.d.ts.map

package/dist/shared-tree/treeAlpha.d.ts.map

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

package/dist/shared-tree/{treeApiAlpha.js → treeAlpha.js}

@@ -13,9 +13,11 @@ const index_js_2 = require("../codec/index.js");
 const index_js_3 = require("../feature-libraries/index.js");
 const independentView_js_1 = require("./independentView.js");
 const schematizingTreeView_js_1 = require("./schematizingTreeView.js");
+const index_js_4 = require("../codec/index.js");
 /**
- * Extensions to {@link Tree} and {@link TreeBeta} which are not yet stable.
- * @sealed @alpha
+ * Extensions to {@link (Tree:variable)} and {@link (TreeBeta:variable)} which are not yet stable.
+ * @see {@link (TreeAlpha:interface)}.
+ * @alpha
  */
 exports.TreeAlpha = {
     branch(node) {
@@ -69,12 +71,12 @@ exports.TreeAlpha = {
         return result;
     },
     importCompressed(schema, compressedData, options) {
+        const config = new index_js_1.TreeViewConfigurationAlpha({ schema });
         const content = {
-            schema: (0, index_js_1.extractPersistedSchema)(schema),
+            schema: (0, index_js_1.extractPersistedSchema)(config, index_js_4.currentVersion),
             tree: compressedData,
             idCompressor: options.idCompressor ?? (0, internal_2.createIdCompressor)(),
         };
-        const config = new index_js_1.TreeViewConfiguration({ schema });
         const view = (0, independentView_js_1.independentInitializedView)(config, options, content);
         return index_js_1.TreeBeta.clone(view.root);
     },
@@ -107,4 +109,4 @@ const versionToFormat = {
     v2_2: 1,
     v2_3: 1,
 };
-//# sourceMappingURL=treeApiAlpha.js.map
+//# sourceMappingURL=treeAlpha.js.map

package/dist/shared-tree/treeAlpha.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeAlpha.js","sourceRoot":"","sources":["../../src/shared-tree/treeAlpha.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert, fail } from \"@fluidframework/core-utils/internal\";\nimport { createIdCompressor } from \"@fluidframework/id-compressor/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\nimport type { IFluidHandle } from \"@fluidframework/core-interfaces\";\nimport type { IIdCompressor } from \"@fluidframework/id-compressor\";\n\nimport {\n\tgetKernel,\n\ttype TreeNode,\n\ttype Unhydrated,\n\tTreeBeta,\n\ttryGetSchema,\n\tcreateFromCursor,\n\tcreateFromInsertable,\n\tcursorFromInsertable,\n\tFieldKind,\n\tnormalizeFieldSchema,\n\ttype ImplicitFieldSchema,\n\ttype InsertableField,\n\ttype TreeFieldFromImplicitField,\n\ttype TreeLeafValue,\n\ttype UnsafeUnknownSchema,\n\tconciseFromCursor,\n\ttype ConciseTree,\n\tapplySchemaToParserOptions,\n\tcursorFromVerbose,\n\tverboseFromCursor,\n\ttype TreeEncodingOptions,\n\ttype VerboseTree,\n\ttoStoredSchema,\n\textractPersistedSchema,\n\ttype TreeBranch,\n\tTreeViewConfigurationAlpha,\n} from \"../simple-tree/index.js\";\nimport type { JsonCompatible } from \"../util/index.js\";\nimport { noopValidator, type FluidClientVersion, type ICodecOptions } from \"../codec/index.js\";\nimport type { ITreeCursorSynchronous } from \"../core/index.js\";\nimport {\n\tcursorForMapTreeField,\n\tdefaultSchemaPolicy,\n\tisTreeValue,\n\tmakeFieldBatchCodec,\n\tmapTreeFromCursor,\n\tTreeCompressionStrategy,\n\ttype FieldBatch,\n\ttype FieldBatchEncodingContext,\n} from \"../feature-libraries/index.js\";\nimport { independentInitializedView, type ViewContent } from \"./independentView.js\";\nimport { SchematizingSimpleTreeView, ViewSlot } from \"./schematizingTreeView.js\";\nimport { currentVersion } from \"../codec/index.js\";\n\n/**\n * Extensions to {@link (Tree:interface)} and {@link (TreeBeta:interface)} which are not yet stable.\n * @remarks\n * Use via the {@link (TreeAlpha:variable)} singleton.\n * @system @sealed @alpha\n */\nexport interface TreeAlpha {\n\t/**\n\t * Retrieve the {@link TreeBranch | branch}, if any, for the given node.\n\t * @param node - The node to query\n\t * @remarks If the node has already been inserted into the tree, this will return the branch associated with that node's {@link TreeView | view}.\n\t * Otherwise, it will return `undefined` (because the node has not yet been inserted and is therefore not part of a branch or view).\n\t *\n\t * This does not fork a new branch, but rather retrieves the _existing_ branch for the node.\n\t * To create a new branch, use e.g. {@link TreeBranch.fork | `myBranch.fork()`}.\n\t */\n\tbranch(node: TreeNode): TreeBranch | undefined;\n\n\t/**\n\t * Construct tree content that is compatible with the field defined by the provided `schema`.\n\t * @param schema - The schema for what to construct. As this is an {@link ImplicitFieldSchema}, a {@link FieldSchema}, {@link TreeNodeSchema} or {@link AllowedTypes} array can be provided.\n\t * @param data - The data used to construct the field content.\n\t * @remarks\n\t * When providing a {@link TreeNodeSchemaClass}, this is the same as invoking its constructor except that an unhydrated node can also be provided.\n\t * This function exists as a generalization that can be used in other cases as well,\n\t * such as when `undefined` might be allowed (for an optional field), or when the type should be inferred from the data when more than one type is possible.\n\t *\n\t * Like with {@link TreeNodeSchemaClass}'s constructor, it's an error to provide an existing node to this API.\n\t * For that case, use {@link (TreeBeta:interface).clone}.\n\t * @privateRemarks\n\t * There should be a way to provide a source for defaulted identifiers, wither via this API or some way to add them to its output later.\n\t */\n\tcreate<const TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema>(\n\t\tschema: UnsafeUnknownSchema extends TSchema\n\t\t\t? ImplicitFieldSchema\n\t\t\t: TSchema & ImplicitFieldSchema,\n\t\tdata: InsertableField<TSchema>,\n\t): Unhydrated<\n\t\tTSchema extends ImplicitFieldSchema\n\t\t\t? TreeFieldFromImplicitField<TSchema>\n\t\t\t: TreeNode | TreeLeafValue | undefined\n\t>;\n\n\t/**\n\t * Less type safe version of {@link (TreeAlpha:interface).create}, suitable for importing data.\n\t * @remarks\n\t * Due to {@link ConciseTree} relying on type inference from the data, its use is somewhat limited.\n\t * This does not support {@link ConciseTree|ConciseTrees} with customized handle encodings or using persisted keys.\n\t * Use \"compressed\" or \"verbose\" formats for more flexibility.\n\t *\n\t * When using this function,\n\t * it is recommend to ensure your schema is unambiguous with {@link ITreeConfigurationOptions.preventAmbiguity}.\n\t * If the schema is ambiguous, consider using {@link (TreeAlpha:interface).create} and {@link Unhydrated} nodes where needed,\n\t * or using {@link (TreeAlpha:interface).(importVerbose:1)} and specify all types.\n\t *\n\t * Documented (and thus recoverable) error handling/reporting for this is not yet implemented,\n\t * but for now most invalid inputs will throw a recoverable error.\n\t */\n\timportConcise<const TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema>(\n\t\tschema: UnsafeUnknownSchema extends TSchema\n\t\t\t? ImplicitFieldSchema\n\t\t\t: TSchema & ImplicitFieldSchema,\n\t\tdata: ConciseTree | undefined,\n\t): Unhydrated<\n\t\tTSchema extends ImplicitFieldSchema\n\t\t\t? TreeFieldFromImplicitField<TSchema>\n\t\t\t: TreeNode | TreeLeafValue | undefined\n\t>;\n\n\t/**\n\t * Construct tree content compatible with a field defined by the provided `schema`.\n\t * @param schema - The schema for what to construct. As this is an {@link ImplicitFieldSchema}, a {@link FieldSchema}, {@link TreeNodeSchema} or {@link AllowedTypes} array can be provided.\n\t * @param data - The data used to construct the field content. See {@link (TreeAlpha:interface).(exportVerbose:1)}.\n\t */\n\timportVerbose<const TSchema extends ImplicitFieldSchema>(\n\t\tschema: TSchema,\n\t\tdata: VerboseTree | undefined,\n\t\toptions?: Partial<TreeEncodingOptions>,\n\t): Unhydrated<TreeFieldFromImplicitField<TSchema>>;\n\n\t/**\n\t * Copy a snapshot of the current version of a TreeNode into a {@link ConciseTree}.\n\t */\n\texportConcise(node: TreeNode | TreeLeafValue, options?: TreeEncodingOptions): ConciseTree;\n\n\t/**\n\t * Copy a snapshot of the current version of a TreeNode into a {@link ConciseTree}, allowing undefined.\n\t */\n\texportConcise(\n\t\tnode: TreeNode | TreeLeafValue | undefined,\n\t\toptions?: TreeEncodingOptions,\n\t): ConciseTree | undefined;\n\n\t/**\n\t * Copy a snapshot of the current version of a TreeNode into a JSON compatible plain old JavaScript Object (except for {@link @fluidframework/core-interfaces#IFluidHandle|IFluidHandles}).\n\t * Uses the {@link VerboseTree} format, with an explicit type on every node.\n\t *\n\t * @remarks\n\t * There are several cases this may be preferred to {@link (TreeAlpha:interface).(exportConcise:1)}:\n\t *\n\t * 1. When not using {@link ITreeConfigurationOptions.preventAmbiguity} (or when using `useStableFieldKeys`), `exportConcise` can produce ambiguous data (the type may be unclear on some nodes).\n\t * `exportVerbose` will always be unambiguous and thus lossless.\n\t *\n\t * 2. When the data might be interpreted without access to the exact same view schema. In such cases, the types may be unknowable if not included.\n\t *\n\t * 3. When easy access to the type is desired.\n\t */\n\texportVerbose(node: TreeNode | TreeLeafValue, options?: TreeEncodingOptions): VerboseTree;\n\n\t/**\n\t * Export the content of the provided `tree` in a compressed JSON compatible format.\n\t * @remarks\n\t * If an `idCompressor` is provided, it will be used to compress identifiers and thus will be needed to decompress the data.\n\t *\n\t * Always uses \"stored\" keys.\n\t * See {@link TreeEncodingOptions.useStoredKeys} for details.\n\t * @privateRemarks\n\t * TODO: It is currently not clear how to work with the idCompressors correctly in the package API.\n\t * Better APIs should probably be provided as there is currently no way to associate an un-hydrated tree with an idCompressor,\n\t * Nor get the correct idCompressor from a subtree to use when exporting it.\n\t * Additionally using `createIdCompressor` to make an idCompressor is `@legacy` and thus not intended for use in this API surface.\n\t * It would probably make more sense if we provided a way to get an idCompressor from the context of a node,\n\t * which could be optional (and settable if missing) for un0hydrated nodes and required for hydrated ones.\n\t * Add in a stable public APi for creating idCompressors, and a way to get them from a tree (without view schema), and that should address the anticipated use-cases.\n\t */\n\texportCompressed(\n\t\ttree: TreeNode | TreeLeafValue,\n\t\toptions: { oldestCompatibleClient: FluidClientVersion; idCompressor?: IIdCompressor },\n\t): JsonCompatible<IFluidHandle>;\n\n\t/**\n\t * Import data encoded by {@link (TreeAlpha:interface).exportCompressed}.\n\t *\n\t * @param schema - Schema with which the data must be compatible. This compatibility is not verified and must be ensured by the caller.\n\t * @param compressedData - Data compressed by {@link (TreeAlpha:interface).exportCompressed}.\n\t * @param options - If {@link (TreeAlpha:interface).exportCompressed} was given an `idCompressor`, it must be provided here.\n\t *\n\t * @remarks\n\t * If the data could have been encoded with a different schema, consider encoding the schema along side it using {@link extractPersistedSchema} and loading the data using {@link independentView}.\n\t *\n\t * @privateRemarks\n\t * This API could be improved:\n\t *\n\t * 1. It could validate that the schema is compatible, and return or throw an error in the invalid case (maybe add a \"try\" version).\n\t *\n\t * 2. A \"try\" version of this could return an error if the data isn't in a supported format (as determined by version and/or JasonValidator).\n\t *\n\t * 3. Requiring the caller provide a JsonValidator isn't the most friendly API. It might be practical to provide a default.\n\t */\n\timportCompressed<const TSchema extends ImplicitFieldSchema>(\n\t\tschema: TSchema,\n\t\tcompressedData: JsonCompatible<IFluidHandle>,\n\t\toptions: { idCompressor?: IIdCompressor } & ICodecOptions,\n\t): Unhydrated<TreeFieldFromImplicitField<TSchema>>;\n}\n\n/**\n * Extensions to {@link (Tree:variable)} and {@link (TreeBeta:variable)} which are not yet stable.\n * @see {@link (TreeAlpha:interface)}.\n * @alpha\n */\nexport const TreeAlpha: TreeAlpha = {\n\tbranch(node: TreeNode): TreeBranch | undefined {\n\t\tconst kernel = getKernel(node);\n\t\tif (!kernel.isHydrated()) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst view = kernel.anchorNode.anchorSet.slots.get(ViewSlot);\n\t\tassert(\n\t\t\tview instanceof SchematizingSimpleTreeView,\n\t\t\t0xa5c /* Unexpected view implementation */,\n\t\t);\n\t\treturn view;\n\t},\n\n\tcreate: createFromInsertable,\n\n\timportConcise<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema>(\n\t\tschema: UnsafeUnknownSchema extends TSchema\n\t\t\t? ImplicitFieldSchema\n\t\t\t: TSchema & ImplicitFieldSchema,\n\t\tdata: ConciseTree | undefined,\n\t): Unhydrated<\n\t\tTSchema extends ImplicitFieldSchema\n\t\t\t? TreeFieldFromImplicitField<TSchema>\n\t\t\t: TreeNode | TreeLeafValue | undefined\n\t> {\n\t\treturn createFromInsertable<UnsafeUnknownSchema>(\n\t\t\tschema,\n\t\t\tdata as InsertableField<UnsafeUnknownSchema>,\n\t\t) as Unhydrated<\n\t\t\tTSchema extends ImplicitFieldSchema\n\t\t\t\t? TreeFieldFromImplicitField<TSchema>\n\t\t\t\t: TreeNode | TreeLeafValue | undefined\n\t\t>;\n\t},\n\n\timportVerbose<const TSchema extends ImplicitFieldSchema>(\n\t\tschema: TSchema,\n\t\tdata: VerboseTree | undefined,\n\t\toptions?: TreeEncodingOptions,\n\t): Unhydrated<TreeFieldFromImplicitField<TSchema>> {\n\t\tconst config: TreeEncodingOptions = { ...options };\n\t\t// Create a config which is standalone, and thus can be used without having to refer back to the schema.\n\t\tconst schemalessConfig = applySchemaToParserOptions(schema, config);\n\t\tif (data === undefined) {\n\t\t\tconst field = normalizeFieldSchema(schema);\n\t\t\tif (field.kind !== FieldKind.Optional) {\n\t\t\t\tthrow new UsageError(\"undefined provided for non-optional field.\");\n\t\t\t}\n\t\t\treturn undefined as Unhydrated<TreeFieldFromImplicitField<TSchema>>;\n\t\t}\n\t\tconst cursor = cursorFromVerbose(data, schemalessConfig);\n\t\treturn createFromCursor(schema, cursor);\n\t},\n\n\texportConcise,\n\n\texportVerbose(node: TreeNode | TreeLeafValue, options?: TreeEncodingOptions): VerboseTree {\n\t\tconst config: TreeEncodingOptions = { ...options };\n\n\t\tconst cursor = borrowCursorFromTreeNodeOrValue(node);\n\t\treturn verboseFromCursor(\n\t\t\tcursor,\n\t\t\ttryGetSchema(node) ?? fail(0xace /* invalid input */),\n\t\t\tconfig,\n\t\t);\n\t},\n\n\texportCompressed(\n\t\tnode: TreeNode | TreeLeafValue,\n\t\toptions: {\n\t\t\toldestCompatibleClient: FluidClientVersion;\n\t\t\tidCompressor?: IIdCompressor;\n\t\t},\n\t): JsonCompatible<IFluidHandle> {\n\t\tconst schema = tryGetSchema(node) ?? fail(0xacf /* invalid input */);\n\t\tconst format = versionToFormat[options.oldestCompatibleClient];\n\t\tconst codec = makeFieldBatchCodec({ jsonValidator: noopValidator }, format);\n\t\tconst cursor = borrowFieldCursorFromTreeNodeOrValue(node);\n\t\tconst batch: FieldBatch = [cursor];\n\t\t// If none provided, create a compressor which will not compress anything.\n\t\tconst idCompressor = options.idCompressor ?? createIdCompressor();\n\t\tconst context: FieldBatchEncodingContext = {\n\t\t\tencodeType: TreeCompressionStrategy.Compressed,\n\t\t\tidCompressor,\n\t\t\toriginatorId: idCompressor.localSessionId, // TODO: Why is this needed?\n\t\t\tschema: { schema: toStoredSchema(schema), policy: defaultSchemaPolicy },\n\t\t};\n\t\tconst result = codec.encode(batch, context);\n\t\treturn result;\n\t},\n\n\timportCompressed<const TSchema extends ImplicitFieldSchema>(\n\t\tschema: TSchema,\n\t\tcompressedData: JsonCompatible<IFluidHandle>,\n\t\toptions: {\n\t\t\tidCompressor?: IIdCompressor;\n\t\t} & ICodecOptions,\n\t): Unhydrated<TreeFieldFromImplicitField<TSchema>> {\n\t\tconst config = new TreeViewConfigurationAlpha({ schema });\n\t\tconst content: ViewContent = {\n\t\t\tschema: extractPersistedSchema(config, currentVersion),\n\t\t\ttree: compressedData,\n\t\t\tidCompressor: options.idCompressor ?? createIdCompressor(),\n\t\t};\n\t\tconst view = independentInitializedView(config, options, content);\n\t\treturn TreeBeta.clone<TSchema>(view.root);\n\t},\n};\n\nfunction exportConcise(\n\tnode: TreeNode | TreeLeafValue,\n\toptions?: TreeEncodingOptions,\n): ConciseTree;\n\nfunction exportConcise(\n\tnode: TreeNode | TreeLeafValue | undefined,\n\toptions?: TreeEncodingOptions,\n): ConciseTree | undefined;\n\nfunction exportConcise(\n\tnode: TreeNode | TreeLeafValue | undefined,\n\toptions?: TreeEncodingOptions,\n): ConciseTree | undefined {\n\tif (node === undefined) {\n\t\treturn undefined;\n\t}\n\tconst config: TreeEncodingOptions = { ...options };\n\n\tconst cursor = borrowCursorFromTreeNodeOrValue(node);\n\treturn conciseFromCursor(\n\t\tcursor,\n\t\ttryGetSchema(node) ?? fail(0xacd /* invalid input */),\n\t\tconfig,\n\t);\n}\n\nfunction borrowCursorFromTreeNodeOrValue(\n\tnode: TreeNode | TreeLeafValue,\n): ITreeCursorSynchronous {\n\tif (isTreeValue(node)) {\n\t\treturn cursorFromInsertable<UnsafeUnknownSchema>(\n\t\t\ttryGetSchema(node) ?? fail(0xad0 /* missing schema */),\n\t\t\tnode,\n\t\t);\n\t}\n\tconst kernel = getKernel(node);\n\tconst cursor = kernel.getOrCreateInnerNode().borrowCursor();\n\treturn cursor;\n}\n\nfunction borrowFieldCursorFromTreeNodeOrValue(\n\tnode: TreeNode | TreeLeafValue,\n): ITreeCursorSynchronous {\n\tconst cursor = borrowCursorFromTreeNodeOrValue(node);\n\t// TODO: avoid copy\n\tconst mapTree = mapTreeFromCursor(cursor);\n\treturn cursorForMapTreeField([mapTree]);\n}\n\nconst versionToFormat = {\n\tv2_0: 1,\n\tv2_1: 1,\n\tv2_2: 1,\n\tv2_3: 1,\n};\n"]}

package/dist/shared-tree-core/branchCommitEnricher.d.ts

@@ -14,7 +14,6 @@ export declare class BranchCommitEnricher<TChange> {
     /**
      * Process the given change, preparing new commits for {@link BranchCommitEnricher.enrich | enrichment}.
      * @param change - The change to process.
-     * @param isAttached - Whether or not the SharedTree is attached to the service.
      */
     processChange(change: SharedTreeBranchChange<TChange>): void;
     /**

package/dist/shared-tree-core/branchCommitEnricher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"branchCommitEnricher.d.ts","sourceRoot":"","sources":["../../src/shared-tree-core/branchCommitEnricher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACN,KAAK,aAAa,EAClB,KAAK,WAAW,EAGhB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,qBAAqB,CAAC;AAE1E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAE1D;;GAEG;AACH,qBAAa,oBAAoB,CAAC,OAAO;;gBAoBvC,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,EAC/B,QAAQ,EAAE,8BAA8B,CAAC,OAAO,CAAC;IAMlD;;;;OAIG;IACI,aAAa,CAAC,MAAM,EAAE,sBAAsB,CAAC,OAAO,CAAC,GAAG,IAAI;IAcnE;;;;OAIG;IACI,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC;IAOjE;;;OAGG;IACI,gBAAgB,IAAI,IAAI;IAI/B;;;OAGG;IACI,iBAAiB,IAAI,IAAI;IAIhC;;;OAGG;IACI,gBAAgB,IAAI,IAAI;IAI/B;;;;OAIG;IACI,qBAAqB,CAAC,UAAU,EAAE,QAAQ,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI;CAM9E"}
+{"version":3,"file":"branchCommitEnricher.d.ts","sourceRoot":"","sources":["../../src/shared-tree-core/branchCommitEnricher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACN,KAAK,aAAa,EAClB,KAAK,WAAW,EAGhB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,qBAAqB,CAAC;AAE1E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAE1D;;GAEG;AACH,qBAAa,oBAAoB,CAAC,OAAO;;gBAoBvC,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,EAC/B,QAAQ,EAAE,8BAA8B,CAAC,OAAO,CAAC;IAMlD;;;OAGG;IACI,aAAa,CAAC,MAAM,EAAE,sBAAsB,CAAC,OAAO,CAAC,GAAG,IAAI;IAcnE;;;;OAIG;IACI,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC;IAOjE;;;OAGG;IACI,gBAAgB,IAAI,IAAI;IAI/B;;;OAGG;IACI,iBAAiB,IAAI,IAAI;IAIhC;;;OAGG;IACI,gBAAgB,IAAI,IAAI;IAI/B;;;;OAIG;IACI,qBAAqB,CAAC,UAAU,EAAE,QAAQ,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI;CAM9E"}

package/dist/shared-tree-core/branchCommitEnricher.js

@@ -47,7 +47,6 @@ class BranchCommitEnricher {
     /**
      * Process the given change, preparing new commits for {@link BranchCommitEnricher.enrich | enrichment}.
      * @param change - The change to process.
-     * @param isAttached - Whether or not the SharedTree is attached to the service.
      */
     processChange(change) {
         if (change.type === "append") {

package/dist/shared-tree-core/branchCommitEnricher.js.map

@@ -1 +1 @@
-{"version":3,"file":"branchCommitEnricher.js","sourceRoot":"","sources":["../../src/shared-tree-core/branchCommitEnricher.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;AAEH,kEAA6D;AAC7D,+CAK0B;AAE1B,qEAA+D;AAG/D;;GAEG;AACH,MAAa,oBAAoB;IAmBhC,YACC,OAA+B,EAC/B,QAAiD;QApBzC,4DAAmD;QACnD,iDAAmD;QAC5D;;;;;;WAMG;QACM,gDAAwE,IAAI,GAAG,EAAE,EAAC;QAE3F;;;;WAIG;QACH,kEAAgE;QAM/D,uBAAA,IAAI,kCAAa,QAAQ,MAAA,CAAC;QAC1B,uBAAA,IAAI,6CAAwB,IAAI,4CAAmB,CAAC,OAAO,EAAE,uBAAA,IAAI,sCAAU,CAAC,MAAA,CAAC;IAC9E,CAAC;IAED;;;;OAIG;IACI,aAAa,CAAC,MAAuC;QAC3D,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC9B,KAAK,MAAM,SAAS,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC;gBAC3C,MAAM,SAAS,GACd,uBAAA,IAAI,uDAA2B,EAAE,KAAjC,IAAI,EAA8B,SAAS,CAAC,QAAQ,CAAC;oBACrD,uBAAA,IAAI,sCAAU,CAAC,uBAAuB,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;gBAE9E,uBAAA,IAAI,6CAAiB,CAAC,GAAG,CAAC,SAAS,EAAE,IAAA,wBAAa,EAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC;YAC3E,CAAC;QACF,CAAC;QAED,uBAAA,IAAI,mDAA8B,SAAS,MAAA,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,MAA4B;QACzC,MAAM,QAAQ,GAAG,uBAAA,IAAI,6CAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACnD,IAAA,iBAAM,EAAC,QAAQ,KAAK,SAAS,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAC;QAC3D,uBAAA,IAAI,6CAAiB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACrC,OAAO,QAAQ,CAAC;IACjB,CAAC;IAED;;;OAGG;IACI,gBAAgB;QACtB,uBAAA,IAAI,iDAAqB,CAAC,gBAAgB,EAAE,CAAC;IAC9C,CAAC;IAED;;;OAGG;IACI,iBAAiB;QACvB,uBAAA,IAAI,mDAA8B,uBAAA,IAAI,iDAAqB,CAAC,iBAAiB,EAAE,MAAA,CAAC;IACjF,CAAC;IAED;;;OAGG;IACI,gBAAgB;QACtB,uBAAA,IAAI,iDAAqB,CAAC,gBAAgB,EAAE,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACI,qBAAqB,CAAC,UAA0C;QACtE,IAAA,iBAAM,EAAC,uBAAA,IAAI,iDAAqB,CAAC,aAAa,EAAE,EAAE,KAAK,CAAC,wBAAwB,CAAC,CAAC;QAClF,KAAK,MAAM,MAAM,IAAI,UAAU,EAAE,CAAC;YACjC,uBAAA,IAAI,iDAAqB,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;QACtD,CAAC;IACF,CAAC;CACD;AA7FD,oDA6FC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\nimport {\n\ttype ChangeRebaser,\n\ttype GraphCommit,\n\treplaceChange,\n\ttype RevisionTag,\n} from \"../core/index.js\";\nimport type { ChangeEnricherReadonlyCheckout } from \"./changeEnricher.js\";\nimport { TransactionEnricher } from \"./transactionEnricher.js\";\nimport type { SharedTreeBranchChange } from \"./branch.js\";\n\n/**\n * Utility for enriching commits from a {@link Branch} before these commits are applied and submitted.\n */\nexport class BranchCommitEnricher<TChange> {\n\treadonly #transactionEnricher: TransactionEnricher<TChange>;\n\treadonly #enricher: ChangeEnricherReadonlyCheckout<TChange>;\n\t/**\n\t * Maps each local commit to the corresponding enriched commit.\n\t * @remarks\n\t * Entries are added when the commits are {@link BranchCommitEnricher.processChange | processed during a change}.\n\t * Each entry is removed when it is {@link BranchCommitEnricher.enrich | retrieved}.\n\t * In the event that an entry is not explicitly removed, it will eventually be {@link WeakMap | dropped from memory} along with the associated commit.\n\t */\n\treadonly #preparedCommits: WeakMap<GraphCommit<TChange>, GraphCommit<TChange>> = new Map();\n\n\t/**\n\t * If defined, a top-level transaction has been {@link BranchCommitEnricher.commitTransaction | committed} since the last {@link BranchCommitEnricher.processChange | change has been processed}.\n\t * Calling this function will compute the composition of that transaction's commits.\n\t * @remarks This function will be reset to undefined after each {@link BranchCommitEnricher.processChange | change is processed}.\n\t */\n\t#getOuterTransactionChange?: (revision: RevisionTag) => TChange;\n\n\tpublic constructor(\n\t\trebaser: ChangeRebaser<TChange>,\n\t\tenricher: ChangeEnricherReadonlyCheckout<TChange>,\n\t) {\n\t\tthis.#enricher = enricher;\n\t\tthis.#transactionEnricher = new TransactionEnricher(rebaser, this.#enricher);\n\t}\n\n\t/**\n\t * Process the given change, preparing new commits for {@link BranchCommitEnricher.enrich | enrichment}.\n\t * @param change - The change to process.\n\t * @param isAttached - Whether or not the SharedTree is attached to the service.\n\t */\n\tpublic processChange(change: SharedTreeBranchChange<TChange>): void {\n\t\tif (change.type === \"append\") {\n\t\t\tfor (const newCommit of change.newCommits) {\n\t\t\t\tconst newChange =\n\t\t\t\t\tthis.#getOuterTransactionChange?.(newCommit.revision) ??\n\t\t\t\t\tthis.#enricher.updateChangeEnrichments(newCommit.change, newCommit.revision);\n\n\t\t\t\tthis.#preparedCommits.set(newCommit, replaceChange(newCommit, newChange));\n\t\t\t}\n\t\t}\n\n\t\tthis.#getOuterTransactionChange = undefined;\n\t}\n\n\t/**\n\t * Retrieves the enriched version of the given commit.\n\t * @param commit - A commit {@link BranchCommitEnricher.processChange | processed during the most recent change}.\n\t * @remarks A commit can only be enriched once - subsequent calls to this method with the same commit will throw an error.\n\t */\n\tpublic enrich(commit: GraphCommit<TChange>): GraphCommit<TChange> {\n\t\tconst prepared = this.#preparedCommits.get(commit);\n\t\tassert(prepared !== undefined, 0x980 /* Unknown commit */);\n\t\tthis.#preparedCommits.delete(commit);\n\t\treturn prepared;\n\t}\n\n\t/**\n\t * Notify the enricher that a new transaction has started.\n\t * @remarks This may be called multiple times without calling {@link BranchCommitEnricher.commitTransaction | commitTransaction}, producing \"nested transactions\".\n\t */\n\tpublic startTransaction(): void {\n\t\tthis.#transactionEnricher.startTransaction();\n\t}\n\n\t/**\n\t * Commit the current transaction.\n\t * @remarks This should be called _before_ the corresponding transaction commit change is {@link BranchCommitEnricher.processChange | processed}.\n\t */\n\tpublic commitTransaction(): void {\n\t\tthis.#getOuterTransactionChange = this.#transactionEnricher.commitTransaction();\n\t}\n\n\t/**\n\t * Notify the enricher that the current transaction has been aborted.\n\t * @remarks This will throw an error if there is no ongoing transaction.\n\t */\n\tpublic abortTransaction(): void {\n\t\tthis.#transactionEnricher.abortTransaction();\n\t}\n\n\t/**\n\t * Add new transaction commits to the current transaction.\n\t * @param newCommits - The new commits to add.\n\t * @remarks This will throw an error if there is no ongoing transaction.\n\t */\n\tpublic addTransactionCommits(newCommits: Iterable<GraphCommit<TChange>>): void {\n\t\tassert(this.#transactionEnricher.isTransacting(), 0xa97 /* Not in transaction */);\n\t\tfor (const commit of newCommits) {\n\t\t\tthis.#transactionEnricher.addTransactionStep(commit);\n\t\t}\n\t}\n}\n"]}
+{"version":3,"file":"branchCommitEnricher.js","sourceRoot":"","sources":["../../src/shared-tree-core/branchCommitEnricher.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;AAEH,kEAA6D;AAC7D,+CAK0B;AAE1B,qEAA+D;AAG/D;;GAEG;AACH,MAAa,oBAAoB;IAmBhC,YACC,OAA+B,EAC/B,QAAiD;QApBzC,4DAAmD;QACnD,iDAAmD;QAC5D;;;;;;WAMG;QACM,gDAAwE,IAAI,GAAG,EAAE,EAAC;QAE3F;;;;WAIG;QACH,kEAAgE;QAM/D,uBAAA,IAAI,kCAAa,QAAQ,MAAA,CAAC;QAC1B,uBAAA,IAAI,6CAAwB,IAAI,4CAAmB,CAAC,OAAO,EAAE,uBAAA,IAAI,sCAAU,CAAC,MAAA,CAAC;IAC9E,CAAC;IAED;;;OAGG;IACI,aAAa,CAAC,MAAuC;QAC3D,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC9B,KAAK,MAAM,SAAS,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC;gBAC3C,MAAM,SAAS,GACd,uBAAA,IAAI,uDAA2B,EAAE,KAAjC,IAAI,EAA8B,SAAS,CAAC,QAAQ,CAAC;oBACrD,uBAAA,IAAI,sCAAU,CAAC,uBAAuB,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;gBAE9E,uBAAA,IAAI,6CAAiB,CAAC,GAAG,CAAC,SAAS,EAAE,IAAA,wBAAa,EAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC;YAC3E,CAAC;QACF,CAAC;QAED,uBAAA,IAAI,mDAA8B,SAAS,MAAA,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,MAA4B;QACzC,MAAM,QAAQ,GAAG,uBAAA,IAAI,6CAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACnD,IAAA,iBAAM,EAAC,QAAQ,KAAK,SAAS,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAC;QAC3D,uBAAA,IAAI,6CAAiB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACrC,OAAO,QAAQ,CAAC;IACjB,CAAC;IAED;;;OAGG;IACI,gBAAgB;QACtB,uBAAA,IAAI,iDAAqB,CAAC,gBAAgB,EAAE,CAAC;IAC9C,CAAC;IAED;;;OAGG;IACI,iBAAiB;QACvB,uBAAA,IAAI,mDAA8B,uBAAA,IAAI,iDAAqB,CAAC,iBAAiB,EAAE,MAAA,CAAC;IACjF,CAAC;IAED;;;OAGG;IACI,gBAAgB;QACtB,uBAAA,IAAI,iDAAqB,CAAC,gBAAgB,EAAE,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACI,qBAAqB,CAAC,UAA0C;QACtE,IAAA,iBAAM,EAAC,uBAAA,IAAI,iDAAqB,CAAC,aAAa,EAAE,EAAE,KAAK,CAAC,wBAAwB,CAAC,CAAC;QAClF,KAAK,MAAM,MAAM,IAAI,UAAU,EAAE,CAAC;YACjC,uBAAA,IAAI,iDAAqB,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;QACtD,CAAC;IACF,CAAC;CACD;AA5FD,oDA4FC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\nimport {\n\ttype ChangeRebaser,\n\ttype GraphCommit,\n\treplaceChange,\n\ttype RevisionTag,\n} from \"../core/index.js\";\nimport type { ChangeEnricherReadonlyCheckout } from \"./changeEnricher.js\";\nimport { TransactionEnricher } from \"./transactionEnricher.js\";\nimport type { SharedTreeBranchChange } from \"./branch.js\";\n\n/**\n * Utility for enriching commits from a {@link Branch} before these commits are applied and submitted.\n */\nexport class BranchCommitEnricher<TChange> {\n\treadonly #transactionEnricher: TransactionEnricher<TChange>;\n\treadonly #enricher: ChangeEnricherReadonlyCheckout<TChange>;\n\t/**\n\t * Maps each local commit to the corresponding enriched commit.\n\t * @remarks\n\t * Entries are added when the commits are {@link BranchCommitEnricher.processChange | processed during a change}.\n\t * Each entry is removed when it is {@link BranchCommitEnricher.enrich | retrieved}.\n\t * In the event that an entry is not explicitly removed, it will eventually be {@link WeakMap | dropped from memory} along with the associated commit.\n\t */\n\treadonly #preparedCommits: WeakMap<GraphCommit<TChange>, GraphCommit<TChange>> = new Map();\n\n\t/**\n\t * If defined, a top-level transaction has been {@link BranchCommitEnricher.commitTransaction | committed} since the last {@link BranchCommitEnricher.processChange | change has been processed}.\n\t * Calling this function will compute the composition of that transaction's commits.\n\t * @remarks This function will be reset to undefined after each {@link BranchCommitEnricher.processChange | change is processed}.\n\t */\n\t#getOuterTransactionChange?: (revision: RevisionTag) => TChange;\n\n\tpublic constructor(\n\t\trebaser: ChangeRebaser<TChange>,\n\t\tenricher: ChangeEnricherReadonlyCheckout<TChange>,\n\t) {\n\t\tthis.#enricher = enricher;\n\t\tthis.#transactionEnricher = new TransactionEnricher(rebaser, this.#enricher);\n\t}\n\n\t/**\n\t * Process the given change, preparing new commits for {@link BranchCommitEnricher.enrich | enrichment}.\n\t * @param change - The change to process.\n\t */\n\tpublic processChange(change: SharedTreeBranchChange<TChange>): void {\n\t\tif (change.type === \"append\") {\n\t\t\tfor (const newCommit of change.newCommits) {\n\t\t\t\tconst newChange =\n\t\t\t\t\tthis.#getOuterTransactionChange?.(newCommit.revision) ??\n\t\t\t\t\tthis.#enricher.updateChangeEnrichments(newCommit.change, newCommit.revision);\n\n\t\t\t\tthis.#preparedCommits.set(newCommit, replaceChange(newCommit, newChange));\n\t\t\t}\n\t\t}\n\n\t\tthis.#getOuterTransactionChange = undefined;\n\t}\n\n\t/**\n\t * Retrieves the enriched version of the given commit.\n\t * @param commit - A commit {@link BranchCommitEnricher.processChange | processed during the most recent change}.\n\t * @remarks A commit can only be enriched once - subsequent calls to this method with the same commit will throw an error.\n\t */\n\tpublic enrich(commit: GraphCommit<TChange>): GraphCommit<TChange> {\n\t\tconst prepared = this.#preparedCommits.get(commit);\n\t\tassert(prepared !== undefined, 0x980 /* Unknown commit */);\n\t\tthis.#preparedCommits.delete(commit);\n\t\treturn prepared;\n\t}\n\n\t/**\n\t * Notify the enricher that a new transaction has started.\n\t * @remarks This may be called multiple times without calling {@link BranchCommitEnricher.commitTransaction | commitTransaction}, producing \"nested transactions\".\n\t */\n\tpublic startTransaction(): void {\n\t\tthis.#transactionEnricher.startTransaction();\n\t}\n\n\t/**\n\t * Commit the current transaction.\n\t * @remarks This should be called _before_ the corresponding transaction commit change is {@link BranchCommitEnricher.processChange | processed}.\n\t */\n\tpublic commitTransaction(): void {\n\t\tthis.#getOuterTransactionChange = this.#transactionEnricher.commitTransaction();\n\t}\n\n\t/**\n\t * Notify the enricher that the current transaction has been aborted.\n\t * @remarks This will throw an error if there is no ongoing transaction.\n\t */\n\tpublic abortTransaction(): void {\n\t\tthis.#transactionEnricher.abortTransaction();\n\t}\n\n\t/**\n\t * Add new transaction commits to the current transaction.\n\t * @param newCommits - The new commits to add.\n\t * @remarks This will throw an error if there is no ongoing transaction.\n\t */\n\tpublic addTransactionCommits(newCommits: Iterable<GraphCommit<TChange>>): void {\n\t\tassert(this.#transactionEnricher.isTransacting(), 0xa97 /* Not in transaction */);\n\t\tfor (const commit of newCommits) {\n\t\t\tthis.#transactionEnricher.addTransactionStep(commit);\n\t\t}\n\t}\n}\n"]}

package/dist/shared-tree-core/transactionEnricher.d.ts

@@ -14,7 +14,7 @@ export declare class TransactionEnricher<TChange> {
     startTransaction(): void;
     /**
      * Commits the current transaction.
-     * @returns If and only if the closed transaction was the outermost transaction, returns a function which can be used to compute the composed change for that transaction's commits.
+     * @returns A function which can be used to compute the composed change for that transaction's commits. Undefined if the transaction is still ongoing or contained no committed changes.
      */
     commitTransaction(): ((revision: RevisionTag) => TChange) | undefined;
     abortTransaction(): void;

package/dist/shared-tree-core/transactionEnricher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transactionEnricher.d.ts","sourceRoot":"","sources":["../../src/shared-tree-core/transactionEnricher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,qBAAqB,CAAC;AAE1E;;GAEG;AACH,qBAAa,mBAAmB,CAAC,OAAO;;gBAatC,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,EAC/B,QAAQ,EAAE,8BAA8B,CAAC,OAAO,CAAC;IAM3C,aAAa,IAAI,OAAO;IAIxB,gBAAgB,IAAI,IAAI;IAI/B;;;OAGG;IACI,iBAAiB,IAAI,CAAC,CAAC,QAAQ,EAAE,WAAW,KAAK,OAAO,CAAC,GAAG,SAAS;IAWrE,gBAAgB,IAAI,IAAI;IAMxB,kBAAkB,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,IAAI;CAQ7D"}
+{"version":3,"file":"transactionEnricher.d.ts","sourceRoot":"","sources":["../../src/shared-tree-core/transactionEnricher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,qBAAqB,CAAC;AAE1E;;GAEG;AACH,qBAAa,mBAAmB,CAAC,OAAO;;gBAatC,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,EAC/B,QAAQ,EAAE,8BAA8B,CAAC,OAAO,CAAC;IAM3C,aAAa,IAAI,OAAO;IAIxB,gBAAgB,IAAI,IAAI;IAI/B;;;OAGG;IACI,iBAAiB,IAAI,CAAC,CAAC,QAAQ,EAAE,WAAW,KAAK,OAAO,CAAC,GAAG,SAAS;IAcrE,gBAAgB,IAAI,IAAI;IAMxB,kBAAkB,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,IAAI;CAQ7D"}