@fluidframework/tree 2.3.1 → 2.4.0-297027

package/dist/simple-tree/core/schemaCaching.d.ts

@@ -2,23 +2,15 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import type { FlexTreeNodeSchema, TreeNodeSchemaBase } from "../../feature-libraries/index.js";
 import type { TreeNodeSchema } from "./treeNodeSchema.js";
 import type { InnerNode } from "./treeNodeKernel.js";
-export declare function cachedFlexSchemaFromClassSchema(schema: TreeNodeSchema): TreeNodeSchemaBase | undefined;
-export declare function setFlexSchemaFromClassSchema(simple: TreeNodeSchema, flex: TreeNodeSchemaBase): void;
+import { type Context } from "./context.js";
 /**
- * Gets the {@link TreeNodeSchema} cached on the provided {@link FlexTreeNodeSchema | flexSchema}.
- * Returns `undefined` if no cached value is found.
- */
-export declare function tryGetSimpleNodeSchema(flexSchema: FlexTreeNodeSchema): TreeNodeSchema | undefined;
-/**
- * Gets the {@link TreeNodeSchema} cached on the provided {@link FlexTreeNodeSchema | flexSchema}.
- * Fails if no cached value is found.
+ * Gets the {@link TreeNodeSchema} for the {@link InnerNode}.
  */
-export declare function getSimpleNodeSchema(flexSchema: FlexTreeNodeSchema): TreeNodeSchema;
+export declare function getSimpleNodeSchemaFromInnerNode(innerNode: InnerNode): TreeNodeSchema;
 /**
- * Gets the {@link TreeNodeSchema} for the {@link InnerNode}.
+ * Gets the {@link Context} for the {@link InnerNode}.
  */
-export declare function getSimpleNodeSchemaFromNode(innerNode: InnerNode): TreeNodeSchema;
+export declare function getSimpleContextFromInnerNode(innerNode: InnerNode): Context;
 //# sourceMappingURL=schemaCaching.d.ts.map

package/dist/simple-tree/core/schemaCaching.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemaCaching.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/schemaCaching.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAG/F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAarD,wBAAgB,+BAA+B,CAC9C,MAAM,EAAE,cAAc,GACpB,kBAAkB,GAAG,SAAS,CAGhC;AAED,wBAAgB,4BAA4B,CAC3C,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,kBAAkB,GACtB,IAAI,CAON;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACrC,UAAU,EAAE,kBAAkB,GAC5B,cAAc,GAAG,SAAS,CAK5B;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,kBAAkB,GAAG,cAAc,CAElF;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,SAAS,GAAG,cAAc,CAIhF"}
+{"version":3,"file":"schemaCaching.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/schemaCaching.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAqB,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AAE/D;;GAEG;AACH,wBAAgB,gCAAgC,CAAC,SAAS,EAAE,SAAS,GAAG,cAAc,CAGrF;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAS3E"}

package/dist/simple-tree/core/schemaCaching.js

@@ -4,58 +4,29 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSimpleNodeSchemaFromNode = exports.getSimpleNodeSchema = exports.tryGetSimpleNodeSchema = exports.setFlexSchemaFromClassSchema = exports.cachedFlexSchemaFromClassSchema = void 0;
+exports.getSimpleContextFromInnerNode = exports.getSimpleNodeSchemaFromInnerNode = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const index_js_1 = require("../../util/index.js");
+const unhydratedFlexTree_js_1 = require("./unhydratedFlexTree.js");
+const context_js_1 = require("./context.js");
 /**
- * A symbol for storing FlexTreeSchema on TreeNodeSchema.
- * Eagerly set on leaves, and lazily set for other cases.
- */
-const flexSchemaSymbol = Symbol(`flexSchema`);
-/**
- * A symbol for storing TreeNodeSchema on FlexTreeNode's schema.
+ * Gets the {@link TreeNodeSchema} for the {@link InnerNode}.
  */
-const simpleNodeSchemaSymbol = Symbol(`simpleNodeSchema`);
-function cachedFlexSchemaFromClassSchema(schema) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return schema[flexSchemaSymbol];
+function getSimpleNodeSchemaFromInnerNode(innerNode) {
+    const context = getSimpleContextFromInnerNode(innerNode);
+    return context.schema.get(innerNode.schema) ?? (0, index_js_1.fail)("missing schema from context");
 }
-exports.cachedFlexSchemaFromClassSchema = cachedFlexSchemaFromClassSchema;
-function setFlexSchemaFromClassSchema(simple, flex) {
-    (0, internal_1.assert)(!(flexSchemaSymbol in simple), 0x91f /* simple schema already marked */);
-    (0, internal_1.assert)(!(simpleNodeSchemaSymbol in flex), 0x920 /* flex schema already marked */);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    simple[flexSchemaSymbol] = flex;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    flex[simpleNodeSchemaSymbol] = simple;
-}
-exports.setFlexSchemaFromClassSchema = setFlexSchemaFromClassSchema;
+exports.getSimpleNodeSchemaFromInnerNode = getSimpleNodeSchemaFromInnerNode;
 /**
- * Gets the {@link TreeNodeSchema} cached on the provided {@link FlexTreeNodeSchema | flexSchema}.
- * Returns `undefined` if no cached value is found.
+ * Gets the {@link Context} for the {@link InnerNode}.
  */
-function tryGetSimpleNodeSchema(flexSchema) {
-    if (simpleNodeSchemaSymbol in flexSchema) {
-        return flexSchema[simpleNodeSchemaSymbol];
+function getSimpleContextFromInnerNode(innerNode) {
+    if (innerNode instanceof unhydratedFlexTree_js_1.UnhydratedFlexTreeNode) {
+        return innerNode.simpleContext;
     }
-    return undefined;
-}
-exports.tryGetSimpleNodeSchema = tryGetSimpleNodeSchema;
-/**
- * Gets the {@link TreeNodeSchema} cached on the provided {@link FlexTreeNodeSchema | flexSchema}.
- * Fails if no cached value is found.
- */
-function getSimpleNodeSchema(flexSchema) {
-    return tryGetSimpleNodeSchema(flexSchema) ?? (0, index_js_1.fail)("missing simple schema");
-}
-exports.getSimpleNodeSchema = getSimpleNodeSchema;
-/**
- * Gets the {@link TreeNodeSchema} for the {@link InnerNode}.
- */
-function getSimpleNodeSchemaFromNode(innerNode) {
-    // TODO: to make this work without depending on flex tree schema, a new caching/lookup mechanism will be required, likely leveraging the FlexTreeContext:
-    // A SimpleTreeContext could be defined and associated with the FlexTreeContext, and used to look up simple-tree schema by identifier.
-    return getSimpleNodeSchema(innerNode.flexSchema);
+    const context = innerNode.anchorNode.anchorSet.slots.get(context_js_1.SimpleContextSlot);
+    (0, internal_1.assert)(context !== undefined, "missing simple tree context");
+    return context;
 }
-exports.getSimpleNodeSchemaFromNode = getSimpleNodeSchemaFromNode;
+exports.getSimpleContextFromInnerNode = getSimpleContextFromInnerNode;
 //# sourceMappingURL=schemaCaching.js.map

package/dist/simple-tree/core/schemaCaching.js.map

@@ -1 +1 @@
-{"version":3,"file":"schemaCaching.js","sourceRoot":"","sources":["../../../src/simple-tree/core/schemaCaching.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAA6D;AAG7D,kDAA2C;AAK3C;;;GAGG;AACH,MAAM,gBAAgB,GAAkB,MAAM,CAAC,YAAY,CAAC,CAAC;AAE7D;;GAEG;AACH,MAAM,sBAAsB,GAAkB,MAAM,CAAC,kBAAkB,CAAC,CAAC;AAEzE,SAAgB,+BAA+B,CAC9C,MAAsB;IAEtB,8DAA8D;IAC9D,OAAQ,MAAc,CAAC,gBAAgB,CAAmC,CAAC;AAC5E,CAAC;AALD,0EAKC;AAED,SAAgB,4BAA4B,CAC3C,MAAsB,EACtB,IAAwB;IAExB,IAAA,iBAAM,EAAC,CAAC,CAAC,gBAAgB,IAAI,MAAM,CAAC,EAAE,KAAK,CAAC,kCAAkC,CAAC,CAAC;IAChF,IAAA,iBAAM,EAAC,CAAC,CAAC,sBAAsB,IAAI,IAAI,CAAC,EAAE,KAAK,CAAC,gCAAgC,CAAC,CAAC;IAClF,8DAA8D;IAC7D,MAAc,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC;IACzC,8DAA8D;IAC7D,IAAY,CAAC,sBAAsB,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AAVD,oEAUC;AAED;;;GAGG;AACH,SAAgB,sBAAsB,CACrC,UAA8B;IAE9B,IAAI,sBAAsB,IAAI,UAAU,EAAE,CAAC;QAC1C,OAAO,UAAU,CAAC,sBAAsB,CAAmB,CAAC;IAC7D,CAAC;IACD,OAAO,SAAS,CAAC;AAClB,CAAC;AAPD,wDAOC;AAED;;;GAGG;AACH,SAAgB,mBAAmB,CAAC,UAA8B;IACjE,OAAO,sBAAsB,CAAC,UAAU,CAAC,IAAI,IAAA,eAAI,EAAC,uBAAuB,CAAC,CAAC;AAC5E,CAAC;AAFD,kDAEC;AAED;;GAEG;AACH,SAAgB,2BAA2B,CAAC,SAAoB;IAC/D,yJAAyJ;IACzJ,sIAAsI;IACtI,OAAO,mBAAmB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;AAClD,CAAC;AAJD,kEAIC","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\";\n\nimport type { FlexTreeNodeSchema, TreeNodeSchemaBase } from \"../../feature-libraries/index.js\";\nimport { fail } from \"../../util/index.js\";\n\nimport type { TreeNodeSchema } from \"./treeNodeSchema.js\";\nimport type { InnerNode } from \"./treeNodeKernel.js\";\n\n/**\n * A symbol for storing FlexTreeSchema on TreeNodeSchema.\n * Eagerly set on leaves, and lazily set for other cases.\n */\nconst flexSchemaSymbol: unique symbol = Symbol(`flexSchema`);\n\n/**\n * A symbol for storing TreeNodeSchema on FlexTreeNode's schema.\n */\nconst simpleNodeSchemaSymbol: unique symbol = Symbol(`simpleNodeSchema`);\n\nexport function cachedFlexSchemaFromClassSchema(\n\tschema: TreeNodeSchema,\n): TreeNodeSchemaBase | undefined {\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\treturn (schema as any)[flexSchemaSymbol] as TreeNodeSchemaBase | undefined;\n}\n\nexport function setFlexSchemaFromClassSchema(\n\tsimple: TreeNodeSchema,\n\tflex: TreeNodeSchemaBase,\n): void {\n\tassert(!(flexSchemaSymbol in simple), 0x91f /* simple schema already marked */);\n\tassert(!(simpleNodeSchemaSymbol in flex), 0x920 /* flex schema already marked */);\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t(simple as any)[flexSchemaSymbol] = flex;\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t(flex as any)[simpleNodeSchemaSymbol] = simple;\n}\n\n/**\n * Gets the {@link TreeNodeSchema} cached on the provided {@link FlexTreeNodeSchema | flexSchema}.\n * Returns `undefined` if no cached value is found.\n */\nexport function tryGetSimpleNodeSchema(\n\tflexSchema: FlexTreeNodeSchema,\n): TreeNodeSchema | undefined {\n\tif (simpleNodeSchemaSymbol in flexSchema) {\n\t\treturn flexSchema[simpleNodeSchemaSymbol] as TreeNodeSchema;\n\t}\n\treturn undefined;\n}\n\n/**\n * Gets the {@link TreeNodeSchema} cached on the provided {@link FlexTreeNodeSchema | flexSchema}.\n * Fails if no cached value is found.\n */\nexport function getSimpleNodeSchema(flexSchema: FlexTreeNodeSchema): TreeNodeSchema {\n\treturn tryGetSimpleNodeSchema(flexSchema) ?? fail(\"missing simple schema\");\n}\n\n/**\n * Gets the {@link TreeNodeSchema} for the {@link InnerNode}.\n */\nexport function getSimpleNodeSchemaFromNode(innerNode: InnerNode): TreeNodeSchema {\n\t// TODO: to make this work without depending on flex tree schema, a new caching/lookup mechanism will be required, likely leveraging the FlexTreeContext:\n\t// A SimpleTreeContext could be defined and associated with the FlexTreeContext, and used to look up simple-tree schema by identifier.\n\treturn getSimpleNodeSchema(innerNode.flexSchema);\n}\n"]}
+{"version":3,"file":"schemaCaching.js","sourceRoot":"","sources":["../../../src/simple-tree/core/schemaCaching.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAA6D;AAE7D,kDAA2C;AAI3C,mEAAiE;AACjE,6CAA+D;AAE/D;;GAEG;AACH,SAAgB,gCAAgC,CAAC,SAAoB;IACpE,MAAM,OAAO,GAAY,6BAA6B,CAAC,SAAS,CAAC,CAAC;IAClE,OAAO,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,IAAA,eAAI,EAAC,6BAA6B,CAAC,CAAC;AACpF,CAAC;AAHD,4EAGC;AAED;;GAEG;AACH,SAAgB,6BAA6B,CAAC,SAAoB;IACjE,IAAI,SAAS,YAAY,8CAAsB,EAAE,CAAC;QACjD,OAAO,SAAS,CAAC,aAAa,CAAC;IAChC,CAAC;IAED,MAAM,OAAO,GAAG,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,8BAAiB,CAAC,CAAC;IAC5E,IAAA,iBAAM,EAAC,OAAO,KAAK,SAAS,EAAE,6BAA6B,CAAC,CAAC;IAE7D,OAAO,OAAO,CAAC;AAChB,CAAC;AATD,sEASC","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\";\n\nimport { fail } from \"../../util/index.js\";\n\nimport type { TreeNodeSchema } from \"./treeNodeSchema.js\";\nimport type { InnerNode } from \"./treeNodeKernel.js\";\nimport { UnhydratedFlexTreeNode } from \"./unhydratedFlexTree.js\";\nimport { SimpleContextSlot, type Context } from \"./context.js\";\n\n/**\n * Gets the {@link TreeNodeSchema} for the {@link InnerNode}.\n */\nexport function getSimpleNodeSchemaFromInnerNode(innerNode: InnerNode): TreeNodeSchema {\n\tconst context: Context = getSimpleContextFromInnerNode(innerNode);\n\treturn context.schema.get(innerNode.schema) ?? fail(\"missing schema from context\");\n}\n\n/**\n * Gets the {@link Context} for the {@link InnerNode}.\n */\nexport function getSimpleContextFromInnerNode(innerNode: InnerNode): Context {\n\tif (innerNode instanceof UnhydratedFlexTreeNode) {\n\t\treturn innerNode.simpleContext;\n\t}\n\n\tconst context = innerNode.anchorNode.anchorSet.slots.get(SimpleContextSlot);\n\tassert(context !== undefined, \"missing simple tree context\");\n\n\treturn context;\n}\n"]}

package/dist/simple-tree/core/treeNodeKernel.d.ts

@@ -5,8 +5,10 @@
 import { type Listenable, type Off } from "../../events/index.js";
 import type { TreeNode, Unhydrated } from "./types.js";
 import { type AnchorEvents, type AnchorNode, type AnchorSet, type UpPath } from "../../core/index.js";
-import { TreeStatus, type FlexTreeNode, type MapTreeNode } from "../../feature-libraries/index.js";
+import { TreeStatus, type FlexTreeNode } from "../../feature-libraries/index.js";
 import type { TreeNodeSchema } from "./treeNodeSchema.js";
+import { type Context } from "./context.js";
+import { UnhydratedFlexTreeNode } from "./unhydratedFlexTree.js";
 export declare function getKernel(node: TreeNode): TreeNodeKernel;
 /**
  * Detects if the given 'candidate' is a TreeNode.
@@ -42,6 +44,7 @@ export declare class TreeNodeKernel implements Listenable<KernelEvents> {
     readonly node: TreeNode;
     readonly schema: TreeNodeSchema;
     private innerNode;
+    private readonly initialContext;
     private disposed;
     /**
      * Generation number which is incremented any time we have an edit on the node.
@@ -57,20 +60,21 @@ export declare class TreeNodeKernel implements Listenable<KernelEvents> {
     /**
      * Create a TreeNodeKernel which can be looked up with {@link getKernel}.
      *
+     * @param initialContext - context from when this node was originally crated.
      * @param innerNode - When unhydrated/raw or marinated the MapTreeNode. FlexTreeNode when cooked.
      * @remarks
      * Exactly one kernel per TreeNode should be created.
      */
-    constructor(node: TreeNode, schema: TreeNodeSchema, innerNode: InnerNode);
+    constructor(node: TreeNode, schema: TreeNodeSchema, innerNode: InnerNode, initialContext: Context);
+    get context(): Context;
     /**
      * Transition from {@link Unhydrated} to hydrated.
      * Bi-directionally associates the given hydrated TreeNode to the given anchor node.
      * @remarks
      * Happens at most once for any given node.
-     * Cleans up mappings to {@link MapTreeNode} - it is assumed that they are no longer needed once the proxy has an anchor node.
+     * Cleans up mappings to {@link UnhydratedFlexTreeNode} - it is assumed that they are no longer needed once the proxy has an anchor node.
      */
     hydrate(anchorNode: AnchorNode): void;
-    isHydrated(): boolean;
     getStatus(): TreeStatus;
     on<K extends keyof KernelEvents>(eventName: K, listener: KernelEvents[K]): Off;
     dispose(): void;
@@ -118,11 +122,29 @@ type KernelEvents = Pick<AnchorEvents, (typeof kernelEvents)[number]>;
  * TODO: The inconsistent handling of "marinated" cases should be cleaned up.
  * Maybe getOrCreateInnerNode should cook marinated nodes so they have a proper InnerNode?
  */
-export type InnerNode = FlexTreeNode | MapTreeNode;
+export type InnerNode = FlexTreeNode | UnhydratedFlexTreeNode;
 /**
- * Retrieves the proxy associated with the given flex node via {@link setInnerNode}, if any.
+ * {@inheritdoc proxyToMapTreeNode}
  */
-export declare function tryGetCachedTreeNode(flexNode: InnerNode): TreeNode | undefined;
+export declare const mapTreeNodeToProxy: WeakMap<UnhydratedFlexTreeNode, TreeNode>;
+/**
+ * An anchor slot which associates an anchor with its corresponding TreeNode, if there is one.
+ * @remarks
+ * For this to work, we have to require that there is at most a single view using a given AnchorSet.
+ * FlexTree already has this assumption, and we also assume there is a single simple-tree per FlexTree, so this is valid.
+ */
+export declare const proxySlot: import("../../core/index.js").AnchorSlot<TreeNode>;
+/**
+ * Retrieves the node associated with the given MapTreeNode node if any.
+ */
+export declare function tryGetTreeNodeFromMapNode(flexNode: UnhydratedFlexTreeNode): TreeNode | undefined;
 export declare function tryDisposeTreeNode(anchorNode: AnchorNode): void;
+/**
+ * Lookup a TreeNodeSchema from a Hydrated FlexTreeNode.
+ * @privateRemarks
+ * This provides a way to access simple tree schema from the flex tree without depending on {@link FlexTreeSchema} which is in the process of being removed.
+ * This is currently limited to hydrated nodes: this limitation will have to be fixed before {@link FlexTreeSchema} can be fully removed.
+ */
+export declare function getTreeNodeSchemaFromHydratedFlexNode(flexNode: FlexTreeNode): TreeNodeSchema;
 export {};
 //# sourceMappingURL=treeNodeKernel.d.ts.map

package/dist/simple-tree/core/treeNodeKernel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treeNodeKernel.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/treeNodeKernel.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAIN,KAAK,UAAU,EACf,KAAK,GAAG,EACR,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAEN,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,MAAM,EACX,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAQN,UAAU,EAEV,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAQ1D,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,cAAc,CAIxD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,IAAI,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC,CAE3F;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,cAAc,CAG/E;AAED;;;;;GAKG;AACH,qBAAa,cAAe,YAAW,UAAU,CAAC,YAAY,CAAC;;aAyD7C,IAAI,EAAE,QAAQ;aACd,MAAM,EAAE,cAAc;IACtC,OAAO,CAAC,SAAS;IA1DlB,OAAO,CAAC,QAAQ,CAAS;IAEzB;;;;;;;;;OASG;IACI,gBAAgB,EAAE,MAAM,CAAK;IAoCpC;;;;;;OAMG;gBAEc,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,cAAc,EAC9B,SAAS,EAAE,SAAS;IAkB7B;;;;;;OAMG;IACI,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAuCrC,UAAU,IAAI,OAAO;IAKrB,SAAS,IAAI,UAAU;IAoBvB,EAAE,CAAC,CAAC,SAAS,MAAM,YAAY,EAAE,SAAS,EAAE,CAAC,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,GAAG;IAI9E,OAAO,IAAI,IAAI;IAQtB;;;;;;;OAOG;IACI,oBAAoB,CAAC,UAAU,UAAQ,GAAG,SAAS;IAiC1D;;;;;;;;;;OAUG;IACI,WAAW,CAAC,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU;IAiBhE;;;;;;OAMG;IACI,eAAe,IAAI,SAAS,GAAG,SAAS;CAgB/C;AAOD,QAAA,MAAM,YAAY,oEAAqE,CAAC;AAExF,KAAK,YAAY,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAEtE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG,WAAW,CAAC;AAenD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,CAO9E;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAM/D"}
+{"version":3,"file":"treeNodeKernel.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/treeNodeKernel.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAiB,KAAK,UAAU,EAAE,KAAK,GAAG,EAAE,MAAM,uBAAuB,CAAC;AACjF,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAEN,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,MAAM,EACX,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAON,UAAU,EAEV,KAAK,YAAY,EACjB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAK1D,OAAO,EAAqB,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAIjE,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,cAAc,CAIxD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,IAAI,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC,CAE3F;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,cAAc,CAG/E;AAqBD;;;;;GAKG;AACH,qBAAa,cAAe,YAAW,UAAU,CAAC,YAAY,CAAC;;aAoC7C,IAAI,EAAE,QAAQ;aACd,MAAM,EAAE,cAAc;IACtC,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAtChC,OAAO,CAAC,QAAQ,CAAS;IAEzB;;;;;;;;;OASG;IACI,gBAAgB,EAAE,MAAM,CAAK;IAcpC;;;;;;;OAOG;gBAEc,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,cAAc,EAC9B,SAAS,EAAE,SAAS,EACX,cAAc,EAAE,OAAO;IAuCzC,IAAW,OAAO,IAAI,OAAO,CAS5B;IAED;;;;;;OAMG;IACI,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAqCrC,SAAS,IAAI,UAAU;IAoBvB,EAAE,CAAC,CAAC,SAAS,MAAM,YAAY,EAAE,SAAS,EAAE,CAAC,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,GAAG;IAS9E,OAAO,IAAI,IAAI;IAUtB;;;;;;;OAOG;IACI,oBAAoB,CAAC,UAAU,UAAQ,GAAG,SAAS;IAgC1D;;;;;;;;;;OAUG;IACI,WAAW,CAAC,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU;IAiBhE;;;;;;OAMG;IACI,eAAe,IAAI,SAAS,GAAG,SAAS;CAe/C;AAOD,QAAA,MAAM,YAAY,oEAAqE,CAAC;AAExF,KAAK,YAAY,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAEtE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG,sBAAsB,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,kBAAkB,2CAAkD,CAAC;AAElF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,oDAAyB,CAAC;AAEhD;;GAEG;AACH,wBAAgB,yBAAyB,CACxC,QAAQ,EAAE,sBAAsB,GAC9B,QAAQ,GAAG,SAAS,CAEtB;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAM/D;AAED;;;;;GAKG;AACH,wBAAgB,qCAAqC,CAAC,QAAQ,EAAE,YAAY,GAAG,cAAc,CAW5F"}

package/dist/simple-tree/core/treeNodeKernel.js

@@ -14,9 +14,9 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _TreeNodeKernel_instances, _TreeNodeKernel_hydrated, _TreeNodeKernel_preHydrationEvents, _TreeNodeKernel_events_get;
+var _TreeNodeKernel_hydrationState, _TreeNodeKernel_unhydratedEvents;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryDisposeTreeNode = exports.tryGetCachedTreeNode = exports.TreeNodeKernel = exports.tryGetTreeNodeSchema = exports.isTreeNode = exports.getKernel = void 0;
+exports.getTreeNodeSchemaFromHydratedFlexNode = exports.tryDisposeTreeNode = exports.tryGetTreeNodeFromMapNode = exports.proxySlot = exports.mapTreeNodeToProxy = exports.TreeNodeKernel = exports.tryGetTreeNodeSchema = exports.isTreeNode = exports.getKernel = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const index_js_1 = require("../../events/index.js");
 const index_js_2 = require("../../core/index.js");
@@ -25,6 +25,8 @@ const index_js_4 = require("../../util/index.js");
 // TODO: decide how to deal with dependencies on flex-tree implementation.
 // eslint-disable-next-line import/no-internal-modules
 const lazyNode_js_1 = require("../../feature-libraries/flex-tree/lazyNode.js");
+const context_js_1 = require("./context.js");
+const unhydratedFlexTree_js_1 = require("./unhydratedFlexTree.js");
 const treeNodeToKernel = new WeakMap();
 function getKernel(node) {
     const kernel = treeNodeToKernel.get(node);
@@ -62,6 +64,10 @@ function tryGetTreeNodeSchema(value) {
     return kernel?.schema;
 }
 exports.tryGetTreeNodeSchema = tryGetTreeNodeSchema;
+/** True if and only if the given {@link HydrationState} is post-hydration */
+function isHydrated(state) {
+    return typeof state === "object";
+}
 /**
  * Contains state and an internal API for managing {@link TreeNode}s.
  * @remarks All {@link TreeNode}s have an associated kernel object.
@@ -72,15 +78,16 @@ class TreeNodeKernel {
     /**
      * Create a TreeNodeKernel which can be looked up with {@link getKernel}.
      *
+     * @param initialContext - context from when this node was originally crated.
      * @param innerNode - When unhydrated/raw or marinated the MapTreeNode. FlexTreeNode when cooked.
      * @remarks
      * Exactly one kernel per TreeNode should be created.
      */
-    constructor(node, schema, innerNode) {
-        _TreeNodeKernel_instances.add(this);
+    constructor(node, schema, innerNode, initialContext) {
         this.node = node;
         this.schema = schema;
         this.innerNode = innerNode;
+        this.initialContext = initialContext;
         this.disposed = false;
         /**
          * Generation number which is incremented any time we have an edit on the node.
@@ -93,42 +100,70 @@ class TreeNodeKernel {
          * but they only way to do that is add a separate public accessor and make it private, which was deemed not worth the boilerplate, runtime overhead and bundle size.
          */
         this.generationNumber = 0;
-        _TreeNodeKernel_hydrated.set(this, void 0);
+        _TreeNodeKernel_hydrationState.set(this, () => { });
         /**
          * Events registered before hydration.
          * @remarks
-         * As an optimization these are allocated lazily as they are usually unused.
+         * Since these are usually not used, they are allocated lazily as an optimization.
+         * The laziness also avoids extra forwarding overhead for events from this kernel's anchor node and also avoids registering for events that are unneeded.
+         * This means optimizations like skipping processing data in subtrees where no subtreeChanged events are subscribed to would be able to work,
+         * since the kernel does not unconditionally subscribe to those events (like a design which simply forwards all events would).
          */
-        _TreeNodeKernel_preHydrationEvents.set(this, void 0);
+        _TreeNodeKernel_unhydratedEvents.set(this, new internal_1.Lazy((index_js_1.createEmitter)));
         (0, internal_1.assert)(!treeNodeToKernel.has(node), 0xa1a /* only one kernel per node can be made */);
         treeNodeToKernel.set(node, this);
-        if ((0, index_js_3.isMapTreeNode)(innerNode)) {
+        if (innerNode instanceof unhydratedFlexTree_js_1.UnhydratedFlexTreeNode) {
             // Unhydrated case
-            mapTreeNodeToProxy.set(innerNode, node);
+            exports.mapTreeNodeToProxy.set(innerNode, node);
+            // Register for change events from the unhydrated flex node.
+            // These will be fired if the unhydrated node is edited, and will also be forwarded later to the hydrated node.
+            __classPrivateFieldSet(this, _TreeNodeKernel_hydrationState, innerNode.events.on("childrenChangedAfterBatch", ({ changedFields }) => {
+                __classPrivateFieldGet(this, _TreeNodeKernel_unhydratedEvents, "f").value.emit("childrenChangedAfterBatch", {
+                    changedFields,
+                });
+                let n = innerNode;
+                while (n !== undefined) {
+                    const treeNode = exports.mapTreeNodeToProxy.get(n);
+                    if (treeNode !== undefined) {
+                        const kernel = getKernel(treeNode);
+                        __classPrivateFieldGet(kernel, _TreeNodeKernel_unhydratedEvents, "f").value.emit("subtreeChangedAfterBatch");
+                    }
+                    // This cast is safe because the parent (if it exists) of an unhydrated flex node is always another unhydrated flex node.
+                    n = n.parentField.parent.parent;
+                }
+            }), "f");
         }
         else {
             // Hydrated case
-            (0, internal_1.assert)(!innerNode.anchorNode.slots.has(proxySlot), 0x7f5 /* Cannot associate an flex node with multiple simple-tree nodes */);
+            (0, internal_1.assert)(!innerNode.anchorNode.slots.has(exports.proxySlot), 0x7f5 /* Cannot associate an flex node with multiple simple-tree nodes */);
             this.hydrate(innerNode.anchorNode);
         }
     }
+    get context() {
+        if (isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
+            // This can't be cached on this.#hydrated during hydration since initial tree is hydrated before the context is cached on the anchorSet.
+            return (__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f")?.anchorNode.anchorSet.slots.get(context_js_1.SimpleContextSlot) ??
+                (0, index_js_4.fail)("missing simple-tree context"));
+        }
+        return this.initialContext;
+    }
     /**
      * Transition from {@link Unhydrated} to hydrated.
      * Bi-directionally associates the given hydrated TreeNode to the given anchor node.
      * @remarks
      * Happens at most once for any given node.
-     * Cleans up mappings to {@link MapTreeNode} - it is assumed that they are no longer needed once the proxy has an anchor node.
+     * Cleans up mappings to {@link UnhydratedFlexTreeNode} - it is assumed that they are no longer needed once the proxy has an anchor node.
      */
     hydrate(anchorNode) {
         (0, internal_1.assert)(!this.disposed, 0xa2a /* cannot hydrate a disposed node */);
-        (0, internal_1.assert)(__classPrivateFieldGet(this, _TreeNodeKernel_hydrated, "f") === undefined, 0xa2b /* hydration should only happen once */);
+        (0, internal_1.assert)(!isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f")), 0xa2b /* hydration should only happen once */);
         // If the this node is raw and thus has a MapTreeNode, forget it:
-        if ((0, index_js_3.isMapTreeNode)(this.innerNode)) {
-            mapTreeNodeToProxy.delete(this.innerNode);
+        if (this.innerNode instanceof unhydratedFlexTree_js_1.UnhydratedFlexTreeNode) {
+            exports.mapTreeNodeToProxy.delete(this.innerNode);
         }
         // However, it's fine for an anchor node to rotate through different proxies when the content at that place in the tree is replaced.
-        anchorNode.slots.set(proxySlot, this.node);
-        __classPrivateFieldSet(this, _TreeNodeKernel_hydrated, {
+        anchorNode.slots.set(exports.proxySlot, this.node);
+        __classPrivateFieldSet(this, _TreeNodeKernel_hydrationState, {
             anchorNode,
             offAnchorNode: new Set([
                 anchorNode.on("afterDestroy", () => this.dispose()),
@@ -139,45 +174,48 @@ class TreeNodeKernel {
             ]),
         }, "f");
         // If needed, register forwarding emitters for events from before hydration
-        if (__classPrivateFieldGet(this, _TreeNodeKernel_preHydrationEvents, "f") !== undefined) {
+        if (__classPrivateFieldGet(this, _TreeNodeKernel_unhydratedEvents, "f").evaluated) {
+            const events = __classPrivateFieldGet(this, _TreeNodeKernel_unhydratedEvents, "f").value;
             for (const eventName of kernelEvents) {
-                if (__classPrivateFieldGet(this, _TreeNodeKernel_preHydrationEvents, "f").hasListeners(eventName)) {
-                    __classPrivateFieldGet(this, _TreeNodeKernel_hydrated, "f").offAnchorNode.add(
+                if (events.hasListeners(eventName)) {
+                    __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").offAnchorNode.add(
                     // Argument is forwarded between matching events, so the type should be correct.
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    anchorNode.on(eventName, (arg) => __classPrivateFieldGet(this, _TreeNodeKernel_preHydrationEvents, "f")?.emit(eventName, arg)));
+                    anchorNode.on(eventName, (arg) => events.emit(eventName, arg)));
                 }
             }
         }
     }
-    isHydrated() {
-        (0, internal_1.assert)(!this.disposed, 0xa2c /* cannot use a disposed node */);
-        return __classPrivateFieldGet(this, _TreeNodeKernel_hydrated, "f") !== undefined;
-    }
     getStatus() {
         if (this.disposed) {
             return index_js_3.TreeStatus.Deleted;
         }
-        if (__classPrivateFieldGet(this, _TreeNodeKernel_hydrated, "f")?.anchorNode === undefined) {
+        if (!isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
             return index_js_3.TreeStatus.New;
         }
         // TODO: Replace this check with the proper check against the cursor state when the cursor becomes part of the kernel
-        const flex = __classPrivateFieldGet(this, _TreeNodeKernel_hydrated, "f").anchorNode.slots.get(index_js_3.flexTreeSlot);
+        const flex = __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").anchorNode.slots.get(index_js_3.flexTreeSlot);
         if (flex !== undefined) {
             (0, internal_1.assert)(flex instanceof index_js_3.LazyEntity, 0x9b4 /* Unexpected flex node implementation */);
             if (flex[index_js_3.isFreedSymbol]()) {
                 return index_js_3.TreeStatus.Deleted;
             }
         }
-        return (0, index_js_3.treeStatusFromAnchorCache)(__classPrivateFieldGet(this, _TreeNodeKernel_hydrated, "f").anchorNode);
+        return (0, index_js_3.treeStatusFromAnchorCache)(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").anchorNode);
     }
     on(eventName, listener) {
-        return __classPrivateFieldGet(this, _TreeNodeKernel_instances, "a", _TreeNodeKernel_events_get).on(eventName, listener);
+        // Retrieve the correct events object based on whether this node is pre or post hydration.
+        const events = isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))
+            ? __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").anchorNode
+            : __classPrivateFieldGet(this, _TreeNodeKernel_unhydratedEvents, "f").value;
+        return events.on(eventName, listener);
     }
     dispose() {
         this.disposed = true;
-        for (const off of __classPrivateFieldGet(this, _TreeNodeKernel_hydrated, "f")?.offAnchorNode ?? []) {
-            off();
+        if (isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
+            for (const off of __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").offAnchorNode) {
+                off();
+            }
         }
         // TODO: go to the context and remove myself from withAnchors
     }
@@ -190,16 +228,15 @@ class TreeNodeKernel {
      * Note that for "marinated" nodes, this FlexTreeNode exists and returns it: it does not return the MapTreeNode which is the current InnerNode.
      */
     getOrCreateInnerNode(allowFreed = false) {
-        if (!(0, index_js_3.isMapTreeNode)(this.innerNode)) {
+        if (!(this.innerNode instanceof unhydratedFlexTree_js_1.UnhydratedFlexTreeNode)) {
             // Cooked case
             return this.innerNode;
         }
-        if (__classPrivateFieldGet(this, _TreeNodeKernel_hydrated, "f") === undefined) {
-            // Unhydrated case
+        if (!isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
             return this.innerNode;
         }
         // Marinated case -> cooked
-        const anchorNode = __classPrivateFieldGet(this, _TreeNodeKernel_hydrated, "f").anchorNode;
+        const anchorNode = __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").anchorNode;
         // The proxy is bound to an anchor node, but it may or may not have an actual flex node yet
         const flexNode = anchorNode.slots.get(index_js_3.flexTreeSlot);
         if (flexNode !== undefined) {
@@ -258,26 +295,17 @@ class TreeNodeKernel {
             // Cooked case
             return this.innerNode;
         }
-        if (__classPrivateFieldGet(this, _TreeNodeKernel_hydrated, "f") === undefined) {
-            // Unhydrated case
+        if (!isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
             return this.innerNode;
         }
         // Marinated case -> cooked
-        const anchorNode = __classPrivateFieldGet(this, _TreeNodeKernel_hydrated, "f").anchorNode;
+        const anchorNode = __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").anchorNode;
         // The proxy is bound to an anchor node, but it may or may not have an actual flex node yet
         return anchorNode.slots.get(index_js_3.flexTreeSlot);
     }
 }
 exports.TreeNodeKernel = TreeNodeKernel;
-_TreeNodeKernel_hydrated = new WeakMap(), _TreeNodeKernel_preHydrationEvents = new WeakMap(), _TreeNodeKernel_instances = new WeakSet(), _TreeNodeKernel_events_get = function _TreeNodeKernel_events_get() {
-    if (__classPrivateFieldGet(this, _TreeNodeKernel_hydrated, "f") === undefined) {
-        __classPrivateFieldSet(this, _TreeNodeKernel_preHydrationEvents, __classPrivateFieldGet(this, _TreeNodeKernel_preHydrationEvents, "f") ?? (0, index_js_1.createEmitter)(), "f");
-        return __classPrivateFieldGet(this, _TreeNodeKernel_preHydrationEvents, "f");
-    }
-    else {
-        return __classPrivateFieldGet(this, _TreeNodeKernel_hydrated, "f").anchorNode;
-    }
-};
+_TreeNodeKernel_hydrationState = new WeakMap(), _TreeNodeKernel_unhydratedEvents = new WeakMap();
 /**
  * Used by {@link anchorProxy} as an optimization to ensure that only one anchor is remembered at a time for a given anchor node
  */
@@ -286,32 +314,40 @@ const kernelEvents = ["childrenChangedAfterBatch", "subtreeChangedAfterBatch"];
 /**
  * {@inheritdoc proxyToMapTreeNode}
  */
-const mapTreeNodeToProxy = new WeakMap();
+exports.mapTreeNodeToProxy = new WeakMap();
 /**
  * An anchor slot which associates an anchor with its corresponding TreeNode, if there is one.
  * @remarks
  * For this to work, we have to require that there is at most a single view using a given AnchorSet.
  * FlexTree already has this assumption, and we also assume there is a single simple-tree per FlexTree, so this is valid.
  */
-const proxySlot = (0, index_js_2.anchorSlot)();
+exports.proxySlot = (0, index_js_2.anchorSlot)();
 /**
- * Retrieves the proxy associated with the given flex node via {@link setInnerNode}, if any.
+ * Retrieves the node associated with the given MapTreeNode node if any.
  */
-function tryGetCachedTreeNode(flexNode) {
-    if ((0, index_js_3.isMapTreeNode)(flexNode)) {
-        // Unhydrated case
-        return mapTreeNodeToProxy.get(flexNode);
-    }
-    // Hydrated case
-    return flexNode.anchorNode.slots.get(proxySlot);
+function tryGetTreeNodeFromMapNode(flexNode) {
+    return exports.mapTreeNodeToProxy.get(flexNode);
 }
-exports.tryGetCachedTreeNode = tryGetCachedTreeNode;
+exports.tryGetTreeNodeFromMapNode = tryGetTreeNodeFromMapNode;
 function tryDisposeTreeNode(anchorNode) {
-    const treeNode = anchorNode.slots.get(proxySlot);
+    const treeNode = anchorNode.slots.get(exports.proxySlot);
     if (treeNode !== undefined) {
         const kernel = getKernel(treeNode);
         kernel.dispose();
     }
 }
 exports.tryDisposeTreeNode = tryDisposeTreeNode;
+/**
+ * Lookup a TreeNodeSchema from a Hydrated FlexTreeNode.
+ * @privateRemarks
+ * This provides a way to access simple tree schema from the flex tree without depending on {@link FlexTreeSchema} which is in the process of being removed.
+ * This is currently limited to hydrated nodes: this limitation will have to be fixed before {@link FlexTreeSchema} can be fully removed.
+ */
+function getTreeNodeSchemaFromHydratedFlexNode(flexNode) {
+    (0, internal_1.assert)(flexNode.context.isHydrated(), "getTreeNodeSchemaFromHydratedFlexNode only allows hydrated flex tree nodes");
+    const context = flexNode.anchorNode.anchorSet.slots.get(context_js_1.SimpleContextSlot) ??
+        (0, index_js_4.fail)("Missing SimpleContextSlot");
+    return context.schema.get(flexNode.schema) ?? (0, index_js_4.fail)("Missing schema");
+}
+exports.getTreeNodeSchemaFromHydratedFlexNode = getTreeNodeSchemaFromHydratedFlexNode;
 //# sourceMappingURL=treeNodeKernel.js.map