@fluidframework/tree 2.1.0 → 2.2.0

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

@@ -0,0 +1,10 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { isTreeNode, TreeNodeKernel, getKernel, tryGetTreeNodeSchema, } from "./treeNodeKernel.js";
+export { type WithType, typeNameSymbol, typeSchemaSymbol } from "./withType.js";
+export { type TreeChangeEvents, TreeNode, type Unhydrated, inPrototypeChain, type InternalTreeNode, privateToken, } from "./types.js";
+export { type TreeNodeSchema, NodeKind, type TreeNodeSchemaClass, type TreeNodeSchemaNonClass, type TreeNodeSchemaCore, } from "./treeNodeSchema.js";
+export { getSimpleNodeSchema, setFlexSchemaFromClassSchema, tryGetSimpleNodeSchema, cachedFlexSchemaFromClassSchema, } from "./schemaCaching.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,UAAU,EACV,cAAc,EACd,SAAS,EACT,oBAAoB,GACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,QAAQ,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAChF,OAAO,EACN,KAAK,gBAAgB,EACrB,QAAQ,EACR,KAAK,UAAU,EACf,gBAAgB,EAChB,KAAK,gBAAgB,EACrB,YAAY,GACZ,MAAM,YAAY,CAAC;AACpB,OAAO,EACN,KAAK,cAAc,EACnB,QAAQ,EACR,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,GACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACN,mBAAmB,EACnB,4BAA4B,EAC5B,sBAAsB,EACtB,+BAA+B,GAC/B,MAAM,oBAAoB,CAAC"}

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

@@ -0,0 +1,27 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachedFlexSchemaFromClassSchema = exports.tryGetSimpleNodeSchema = exports.setFlexSchemaFromClassSchema = exports.getSimpleNodeSchema = exports.NodeKind = exports.privateToken = exports.inPrototypeChain = exports.TreeNode = exports.typeSchemaSymbol = exports.typeNameSymbol = exports.tryGetTreeNodeSchema = exports.getKernel = exports.TreeNodeKernel = exports.isTreeNode = void 0;
+var treeNodeKernel_js_1 = require("./treeNodeKernel.js");
+Object.defineProperty(exports, "isTreeNode", { enumerable: true, get: function () { return treeNodeKernel_js_1.isTreeNode; } });
+Object.defineProperty(exports, "TreeNodeKernel", { enumerable: true, get: function () { return treeNodeKernel_js_1.TreeNodeKernel; } });
+Object.defineProperty(exports, "getKernel", { enumerable: true, get: function () { return treeNodeKernel_js_1.getKernel; } });
+Object.defineProperty(exports, "tryGetTreeNodeSchema", { enumerable: true, get: function () { return treeNodeKernel_js_1.tryGetTreeNodeSchema; } });
+var withType_js_1 = require("./withType.js");
+Object.defineProperty(exports, "typeNameSymbol", { enumerable: true, get: function () { return withType_js_1.typeNameSymbol; } });
+Object.defineProperty(exports, "typeSchemaSymbol", { enumerable: true, get: function () { return withType_js_1.typeSchemaSymbol; } });
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "TreeNode", { enumerable: true, get: function () { return types_js_1.TreeNode; } });
+Object.defineProperty(exports, "inPrototypeChain", { enumerable: true, get: function () { return types_js_1.inPrototypeChain; } });
+Object.defineProperty(exports, "privateToken", { enumerable: true, get: function () { return types_js_1.privateToken; } });
+var treeNodeSchema_js_1 = require("./treeNodeSchema.js");
+Object.defineProperty(exports, "NodeKind", { enumerable: true, get: function () { return treeNodeSchema_js_1.NodeKind; } });
+var schemaCaching_js_1 = require("./schemaCaching.js");
+Object.defineProperty(exports, "getSimpleNodeSchema", { enumerable: true, get: function () { return schemaCaching_js_1.getSimpleNodeSchema; } });
+Object.defineProperty(exports, "setFlexSchemaFromClassSchema", { enumerable: true, get: function () { return schemaCaching_js_1.setFlexSchemaFromClassSchema; } });
+Object.defineProperty(exports, "tryGetSimpleNodeSchema", { enumerable: true, get: function () { return schemaCaching_js_1.tryGetSimpleNodeSchema; } });
+Object.defineProperty(exports, "cachedFlexSchemaFromClassSchema", { enumerable: true, get: function () { return schemaCaching_js_1.cachedFlexSchemaFromClassSchema; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/simple-tree/core/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,yDAK6B;AAJ5B,+GAAA,UAAU,OAAA;AACV,mHAAA,cAAc,OAAA;AACd,8GAAA,SAAS,OAAA;AACT,yHAAA,oBAAoB,OAAA;AAErB,6CAAgF;AAAxD,6GAAA,cAAc,OAAA;AAAE,+GAAA,gBAAgB,OAAA;AACxD,uCAOoB;AALnB,oGAAA,QAAQ,OAAA;AAER,4GAAA,gBAAgB,OAAA;AAEhB,wGAAA,YAAY,OAAA;AAEb,yDAM6B;AAJ5B,6GAAA,QAAQ,OAAA;AAKT,uDAK4B;AAJ3B,uHAAA,mBAAmB,OAAA;AACnB,gIAAA,4BAA4B,OAAA;AAC5B,0HAAA,sBAAsB,OAAA;AACtB,mIAAA,+BAA+B,OAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport {\n\tisTreeNode,\n\tTreeNodeKernel,\n\tgetKernel,\n\ttryGetTreeNodeSchema,\n} from \"./treeNodeKernel.js\";\nexport { type WithType, typeNameSymbol, typeSchemaSymbol } from \"./withType.js\";\nexport {\n\ttype TreeChangeEvents,\n\tTreeNode,\n\ttype Unhydrated,\n\tinPrototypeChain,\n\ttype InternalTreeNode,\n\tprivateToken,\n} from \"./types.js\";\nexport {\n\ttype TreeNodeSchema,\n\tNodeKind,\n\ttype TreeNodeSchemaClass,\n\ttype TreeNodeSchemaNonClass,\n\ttype TreeNodeSchemaCore,\n} from \"./treeNodeSchema.js\";\nexport {\n\tgetSimpleNodeSchema,\n\tsetFlexSchemaFromClassSchema,\n\ttryGetSimpleNodeSchema,\n\tcachedFlexSchemaFromClassSchema,\n} from \"./schemaCaching.js\";\n"]}

package/{lib/simple-tree → dist/simple-tree/core}/schemaCaching.d.ts

@@ -2,8 +2,8 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import type { FlexFieldSchema, FlexTreeNodeSchema, TreeNodeSchemaBase } from "../feature-libraries/index.js";
-import { type FieldSchema, type ImplicitFieldSchema, type TreeNodeSchema } from "./schemaTypes.js";
+import type { FlexTreeNodeSchema, TreeNodeSchemaBase } from "../../feature-libraries/index.js";
+import type { TreeNodeSchema } from "./treeNodeSchema.js";
 export declare function cachedFlexSchemaFromClassSchema(schema: TreeNodeSchema): TreeNodeSchemaBase | undefined;
 export declare function setFlexSchemaFromClassSchema(simple: TreeNodeSchema, flex: TreeNodeSchemaBase): void;
 /**
@@ -16,11 +16,4 @@ export declare function tryGetSimpleNodeSchema(flexSchema: FlexTreeNodeSchema):
  * Fails if no cached value is found.
  */
 export declare function getSimpleNodeSchema(flexSchema: FlexTreeNodeSchema): TreeNodeSchema;
-/**
- * Gets the {@link FieldSchema} which corresponds with the provided {@link FlexFieldSchema | flexSchema}.
- * Caches the result on the provided `flexSchema` for future access.
- * @param flexSchema - The flex schema on which the result will be cached.
- * @param implicitSimpleSchema - The allowed types from which the `FieldSchema` will be derived.
- */
-export declare function getSimpleFieldSchema(flexSchema: FlexFieldSchema, implicitSimpleSchema: ImplicitFieldSchema): FieldSchema;
 //# sourceMappingURL=schemaCaching.d.ts.map

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

@@ -0,0 +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;AAa1D,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"}

package/dist/simple-tree/{schemaCaching.js → core/schemaCaching.js}

@@ -4,10 +4,9 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSimpleFieldSchema = exports.getSimpleNodeSchema = exports.tryGetSimpleNodeSchema = exports.setFlexSchemaFromClassSchema = exports.cachedFlexSchemaFromClassSchema = void 0;
+exports.getSimpleNodeSchema = exports.tryGetSimpleNodeSchema = exports.setFlexSchemaFromClassSchema = exports.cachedFlexSchemaFromClassSchema = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
-const index_js_1 = require("../util/index.js");
-const schemaTypes_js_1 = require("./schemaTypes.js");
+const index_js_1 = require("../../util/index.js");
 /**
  * A symbol for storing FlexTreeSchema on TreeNodeSchema.
  * Eagerly set on leaves, and lazily set for other cases.
@@ -17,10 +16,6 @@ const flexSchemaSymbol = Symbol(`flexSchema`);
  * A symbol for storing TreeNodeSchema on FlexTreeNode's schema.
  */
 const simpleNodeSchemaSymbol = Symbol(`simpleNodeSchema`);
-/**
- * A symbol for storing {@link FieldSchema}s on a {@link FlexFieldSchema}.
- */
-const simpleFieldSchemaSymbol = Symbol(`simpleFieldSchema`);
 function cachedFlexSchemaFromClassSchema(schema) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return schema[flexSchemaSymbol];
@@ -54,20 +49,4 @@ function getSimpleNodeSchema(flexSchema) {
     return tryGetSimpleNodeSchema(flexSchema) ?? (0, index_js_1.fail)("missing simple schema");
 }
 exports.getSimpleNodeSchema = getSimpleNodeSchema;
-/**
- * Gets the {@link FieldSchema} which corresponds with the provided {@link FlexFieldSchema | flexSchema}.
- * Caches the result on the provided `flexSchema` for future access.
- * @param flexSchema - The flex schema on which the result will be cached.
- * @param implicitSimpleSchema - The allowed types from which the `FieldSchema` will be derived.
- */
-function getSimpleFieldSchema(flexSchema, implicitSimpleSchema) {
-    if (simpleFieldSchemaSymbol in flexSchema) {
-        return flexSchema[simpleFieldSchemaSymbol];
-    }
-    const fieldSchema = (0, schemaTypes_js_1.normalizeFieldSchema)(implicitSimpleSchema);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    flexSchema[simpleFieldSchemaSymbol] = fieldSchema;
-    return fieldSchema;
-}
-exports.getSimpleFieldSchema = getSimpleFieldSchema;
 //# sourceMappingURL=schemaCaching.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaCaching.js","sourceRoot":"","sources":["../../../src/simple-tree/core/schemaCaching.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAA6D;AAG7D,kDAA2C;AAI3C;;;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","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\";\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"]}

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

@@ -0,0 +1,57 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { type Listenable, type Off } from "../../events/index.js";
+import type { TreeChangeEvents, TreeNode, Unhydrated } from "./types.js";
+import type { AnchorNode } from "../../core/index.js";
+import { TreeStatus } from "../../feature-libraries/index.js";
+import type { TreeNodeSchema } from "./treeNodeSchema.js";
+export declare function getKernel(node: TreeNode): TreeNodeKernel;
+/**
+ * Detects if the given 'candidate' is a TreeNode.
+ *
+ * @remarks
+ * Supports both Hydrated and {@link Unhydrated} TreeNodes, both of which return true.
+ *
+ * Because the common usage is to check if a value being inserted/set is a TreeNode,
+ * this function permits calling with primitives as well as objects.
+ *
+ * Primitives will always return false (as they are copies of data, not references to nodes).
+ *
+ * @param candidate - Value which may be a TreeNode
+ * @returns true if the given 'candidate' is a hydrated TreeNode.
+ */
+export declare function isTreeNode(candidate: unknown): candidate is TreeNode | Unhydrated<TreeNode>;
+/**
+ * Returns a schema for a value if the value is a {@link TreeNode}.
+ *
+ * Returns undefined for other values.
+ * @remarks
+ * Does not give schema for a {@link TreeLeafValue}.
+ */
+export declare function tryGetTreeNodeSchema(value: unknown): undefined | TreeNodeSchema;
+/**
+ * Contains state and an internal API for managing {@link TreeNode}s.
+ * @remarks All {@link TreeNode}s have an associated kernel object.
+ * The kernel has the same lifetime as the node and spans both its unhydrated and hydrated states.
+ * When hydration occurs, the kernel is notified via the {@link TreeNodeKernel.hydrate | hydrate} method.
+ */
+export declare class TreeNodeKernel implements Listenable<TreeChangeEvents> {
+    #private;
+    readonly node: TreeNode;
+    readonly schema: TreeNodeSchema;
+    /**
+     * Create a TreeNodeKernel which can be looked up with {@link getKernel}.
+     * @remarks
+     * Exactly one kernel per TreeNode should be created.
+     */
+    constructor(node: TreeNode, schema: TreeNodeSchema);
+    hydrate(anchorNode: AnchorNode): void;
+    dehydrate(): void;
+    isHydrated(): boolean;
+    getStatus(): TreeStatus;
+    on<K extends keyof TreeChangeEvents>(eventName: K, listener: TreeChangeEvents[K]): Off;
+    dispose(): void;
+}
+//# sourceMappingURL=treeNodeKernel.d.ts.map

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

@@ -0,0 +1 @@
+{"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,gBAAgB,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAIN,UAAU,EAEV,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAI1D,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,gBAAgB,CAAC;;aAajD,IAAI,EAAE,QAAQ;aACd,MAAM,EAAE,cAAc;IAPvC;;;;OAIG;gBAEc,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,cAAc;IAMhC,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAqBrC,SAAS,IAAI,IAAI;IAKjB,UAAU,IAAI,OAAO;IAIrB,SAAS,IAAI,UAAU;IAiBvB,EAAE,CAAC,CAAC,SAAS,MAAM,gBAAgB,EACzC,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAC3B,GAAG;IAIC,OAAO,IAAI,IAAI;CAItB"}

package/dist/simple-tree/{treeNodeKernel.js → core/treeNodeKernel.js}

@@ -16,10 +16,47 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 };
 var _TreeNodeKernel_hydrated, _TreeNodeKernel_events;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeNodeKernel = void 0;
+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("../feature-libraries/index.js");
+const index_js_1 = require("../../events/index.js");
+const index_js_2 = require("../../feature-libraries/index.js");
+const treeNodeToKernel = new WeakMap();
+function getKernel(node) {
+    const kernel = treeNodeToKernel.get(node);
+    (0, internal_1.assert)(kernel !== undefined, 0x9b1 /* Expected tree node to have kernel */);
+    return kernel;
+}
+exports.getKernel = getKernel;
+/**
+ * Detects if the given 'candidate' is a TreeNode.
+ *
+ * @remarks
+ * Supports both Hydrated and {@link Unhydrated} TreeNodes, both of which return true.
+ *
+ * Because the common usage is to check if a value being inserted/set is a TreeNode,
+ * this function permits calling with primitives as well as objects.
+ *
+ * Primitives will always return false (as they are copies of data, not references to nodes).
+ *
+ * @param candidate - Value which may be a TreeNode
+ * @returns true if the given 'candidate' is a hydrated TreeNode.
+ */
+function isTreeNode(candidate) {
+    return treeNodeToKernel.has(candidate);
+}
+exports.isTreeNode = isTreeNode;
+/**
+ * Returns a schema for a value if the value is a {@link TreeNode}.
+ *
+ * Returns undefined for other values.
+ * @remarks
+ * Does not give schema for a {@link TreeLeafValue}.
+ */
+function tryGetTreeNodeSchema(value) {
+    const kernel = treeNodeToKernel.get(value);
+    return kernel?.schema;
+}
+exports.tryGetTreeNodeSchema = tryGetTreeNodeSchema;
 /**
  * Contains state and an internal API for managing {@link TreeNode}s.
  * @remarks All {@link TreeNode}s have an associated kernel object.
@@ -27,10 +64,18 @@ const index_js_2 = require("../feature-libraries/index.js");
  * When hydration occurs, the kernel is notified via the {@link TreeNodeKernel.hydrate | hydrate} method.
  */
 class TreeNodeKernel {
-    constructor(node) {
+    /**
+     * Create a TreeNodeKernel which can be looked up with {@link getKernel}.
+     * @remarks
+     * Exactly one kernel per TreeNode should be created.
+     */
+    constructor(node, schema) {
         this.node = node;
+        this.schema = schema;
         _TreeNodeKernel_hydrated.set(this, void 0);
         _TreeNodeKernel_events.set(this, (0, index_js_1.createEmitter)());
+        (0, internal_1.assert)(!treeNodeToKernel.has(node), 0xa1a /* only one kernel per node can be made */);
+        treeNodeToKernel.set(node, this);
     }
     hydrate(anchorNode) {
         const offChildrenChanged = anchorNode.on("childrenChangedAfterBatch", () => {

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

@@ -0,0 +1 @@
+{"version":3,"file":"treeNodeKernel.js","sourceRoot":"","sources":["../../../src/simple-tree/core/treeNodeKernel.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 } from \"@fluidframework/core-utils/internal\";\nimport { createEmitter, type Listenable, type Off } from \"../../events/index.js\";\nimport type { TreeChangeEvents, TreeNode, Unhydrated } from \"./types.js\";\nimport type { AnchorNode } from \"../../core/index.js\";\nimport {\n\tflexTreeSlot,\n\tisFreedSymbol,\n\tLazyEntity,\n\tTreeStatus,\n\ttreeStatusFromAnchorCache,\n} from \"../../feature-libraries/index.js\";\nimport type { TreeNodeSchema } from \"./treeNodeSchema.js\";\n\nconst treeNodeToKernel = new WeakMap<TreeNode, TreeNodeKernel>();\n\nexport function getKernel(node: TreeNode): TreeNodeKernel {\n\tconst kernel = treeNodeToKernel.get(node);\n\tassert(kernel !== undefined, 0x9b1 /* Expected tree node to have kernel */);\n\treturn kernel;\n}\n\n/**\n * Detects if the given 'candidate' is a TreeNode.\n *\n * @remarks\n * Supports both Hydrated and {@link Unhydrated} TreeNodes, both of which return true.\n *\n * Because the common usage is to check if a value being inserted/set is a TreeNode,\n * this function permits calling with primitives as well as objects.\n *\n * Primitives will always return false (as they are copies of data, not references to nodes).\n *\n * @param candidate - Value which may be a TreeNode\n * @returns true if the given 'candidate' is a hydrated TreeNode.\n */\nexport function isTreeNode(candidate: unknown): candidate is TreeNode | Unhydrated<TreeNode> {\n\treturn treeNodeToKernel.has(candidate as TreeNode);\n}\n\n/**\n * Returns a schema for a value if the value is a {@link TreeNode}.\n *\n * Returns undefined for other values.\n * @remarks\n * Does not give schema for a {@link TreeLeafValue}.\n */\nexport function tryGetTreeNodeSchema(value: unknown): undefined | TreeNodeSchema {\n\tconst kernel = treeNodeToKernel.get(value as TreeNode);\n\treturn kernel?.schema;\n}\n\n/**\n * Contains state and an internal API for managing {@link TreeNode}s.\n * @remarks All {@link TreeNode}s have an associated kernel object.\n * The kernel has the same lifetime as the node and spans both its unhydrated and hydrated states.\n * When hydration occurs, the kernel is notified via the {@link TreeNodeKernel.hydrate | hydrate} method.\n */\nexport class TreeNodeKernel implements Listenable<TreeChangeEvents> {\n\t#hydrated?: {\n\t\tanchorNode: AnchorNode;\n\t\toffAnchorNode: Off;\n\t};\n\t#events = createEmitter<TreeChangeEvents>();\n\n\t/**\n\t * Create a TreeNodeKernel which can be looked up with {@link getKernel}.\n\t * @remarks\n\t * Exactly one kernel per TreeNode should be created.\n\t */\n\tpublic constructor(\n\t\tpublic readonly node: TreeNode,\n\t\tpublic readonly schema: TreeNodeSchema,\n\t) {\n\t\tassert(!treeNodeToKernel.has(node), 0xa1a /* only one kernel per node can be made */);\n\t\ttreeNodeToKernel.set(node, this);\n\t}\n\n\tpublic hydrate(anchorNode: AnchorNode): void {\n\t\tconst offChildrenChanged = anchorNode.on(\"childrenChangedAfterBatch\", () => {\n\t\t\tthis.#events.emit(\"nodeChanged\");\n\t\t});\n\n\t\tconst offSubtreeChanged = anchorNode.on(\"subtreeChangedAfterBatch\", () => {\n\t\t\tthis.#events.emit(\"treeChanged\");\n\t\t});\n\n\t\tconst offAfterDestroy = anchorNode.on(\"afterDestroy\", () => this.dispose());\n\n\t\tthis.#hydrated = {\n\t\t\tanchorNode,\n\t\t\toffAnchorNode: () => {\n\t\t\t\toffChildrenChanged();\n\t\t\t\toffSubtreeChanged();\n\t\t\t\toffAfterDestroy();\n\t\t\t},\n\t\t};\n\t}\n\n\tpublic dehydrate(): void {\n\t\tthis.#hydrated?.offAnchorNode?.();\n\t\tthis.#hydrated = undefined;\n\t}\n\n\tpublic isHydrated(): boolean {\n\t\treturn this.#hydrated !== undefined;\n\t}\n\n\tpublic getStatus(): TreeStatus {\n\t\tif (this.#hydrated?.anchorNode === undefined) {\n\t\t\treturn TreeStatus.New;\n\t\t}\n\n\t\t// TODO: Replace this check with the proper check against the cursor state when the cursor becomes part of the kernel\n\t\tconst flex = this.#hydrated.anchorNode.slots.get(flexTreeSlot);\n\t\tif (flex !== undefined) {\n\t\t\tassert(flex instanceof LazyEntity, 0x9b4 /* Unexpected flex node implementation */);\n\t\t\tif (flex[isFreedSymbol]()) {\n\t\t\t\treturn TreeStatus.Deleted;\n\t\t\t}\n\t\t}\n\n\t\treturn treeStatusFromAnchorCache(this.#hydrated.anchorNode);\n\t}\n\n\tpublic on<K extends keyof TreeChangeEvents>(\n\t\teventName: K,\n\t\tlistener: TreeChangeEvents[K],\n\t): Off {\n\t\treturn this.#events.on(eventName, listener);\n\t}\n\n\tpublic dispose(): void {\n\t\tthis.dehydrate();\n\t\t// TODO: go to the context and remove myself from withAnchors\n\t}\n}\n"]}

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

@@ -0,0 +1,149 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import type { InternalTreeNode, Unhydrated } from "./types.js";
+/**
+ * Schema for a tree node.
+ * @typeParam Name - The full (including scope) name/identifier for the schema.
+ * @typeParam Kind - Which kind of node this schema is for.
+ * @typeParam TNode - API for nodes that use this schema.
+ * @typeParam TBuild - Data which can be used to construct an {@link Unhydrated} node of this type.
+ * @typeParam Info - Data used when defining this schema.
+ * @remarks
+ * Captures the schema both as runtime data and compile time type information.
+ * @sealed @public
+ */
+export type TreeNodeSchema<Name extends string = string, Kind extends NodeKind = NodeKind, TNode = unknown, TBuild = never, ImplicitlyConstructable extends boolean = boolean, Info = unknown> = TreeNodeSchemaClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info> | TreeNodeSchemaNonClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;
+/**
+ * Schema which is not a class.
+ * @remarks
+ * This is used for schema which cannot have their instances constructed using constructors, like leaf schema.
+ * @privateRemarks
+ * Non-class based schema can have issues with recursive types due to https://github.com/microsoft/TypeScript/issues/55832.
+ * @sealed @public
+ */
+export interface TreeNodeSchemaNonClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
+    create(data: TInsertable): TNode;
+}
+/**
+ * Tree node schema which is implemented using a class.
+ * @remarks
+ * Instances of this class are nodes in the tree.
+ * This is also a constructor so that it can be subclassed.
+ *
+ * Using classes in this way allows introducing a named type and a named value at the same time, helping keep the runtime and compile time information together and easy to refer to un a uniform way.
+ * Additionally, this works around https://github.com/microsoft/TypeScript/issues/55832 which causes similar patterns with less explicit types to infer "any" in the d.ts file.
+ *
+ * When sub-classing a a `TreeNodeSchemaClass`, some extra rules must be followed:
+ *
+ * - Only ever use a single class from the schema's class hierarchy within a document and its schema.
+ * For example, if using {@link SchemaFactory.object} you can do:
+ * ```typescript
+ * // Recommended "customizable" object schema pattern.
+ * class Good extends schemaFactory.object("A", {
+ * 	exampleField: schemaFactory.number,
+ * }) {
+ * 	public exampleCustomMethod(): void {
+ * 		this.exampleField++;
+ * 	}
+ * }
+ * ```
+ * But should avoid:
+ * ```typescript
+ * // This by itself is ok, and opts into "POJO mode".
+ * const base = schemaFactory.object("A", {});
+ * // This is a bad pattern since it leaves two classes in scope which derive from the same SchemaFactory defined class.
+ * // If both get used, its an error!
+ * class Invalid extends base {}
+ * ```
+ * - Do not modify the constructor input parameter types or values:
+ * ```typescript
+ * class Invalid extends schemaFactory.object("A", {
+ * 	exampleField: schemaFactory.number,
+ * }) {
+ * 	// This Modifies the type of the constructor input.
+ * 	// This is unsupported due to programmatic access to the constructor being used internally.
+ * 	public constructor(a: number) {
+ * 		super({ exampleField: a });
+ * 	}
+ * }
+ * ```
+ * @sealed @public
+ */
+export interface TreeNodeSchemaClass<out Name extends string = string, out Kind extends NodeKind = NodeKind, out TNode = unknown, in TInsertable = never, out ImplicitlyConstructable extends boolean = boolean, out Info = unknown> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {
+    /**
+     * Constructs an {@link Unhydrated} node with this schema.
+     * @remarks
+     * This constructor is also used internally to construct hydrated nodes with a different parameter type.
+     * Therefore, overriding this constructor with different argument types is not type-safe and is not supported.
+     * @sealed
+     */
+    new (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;
+}
+/**
+ * Data common to all tree node schema.
+ * @remarks
+ * Implementation detail of {@link TreeNodeSchema} which should be accessed instead of referring to this type directly.
+ * @sealed @public
+ */
+export interface TreeNodeSchemaCore<out Name extends string, out Kind extends NodeKind, out ImplicitlyConstructable extends boolean, out Info = unknown> {
+    /**
+     * Unique (within a document's schema) identifier used to associate nodes with their schema.
+     * @remarks
+     * This is used when encoding nodes, and when decoding nodes to re-associate them with the schema.
+     * Since this decoding may happen in a different version of the application (or even a different application altogether),
+     * this identifier should generally correspond to some specific semantics for the data (how to interpret the node with this identifier).
+     * Any time the semantics change such that data would be misinterpreted if the old semantics were applied
+     * (for example the units of a value are changed),
+     * it is best practice to pick a new identifier.
+     */
+    readonly identifier: Name;
+    readonly kind: Kind;
+    /**
+     * Data used to define this schema.
+     *
+     * @remarks
+     * The format depends on the kind of node it is for.
+     * For example, the "object" node kind could store the field schema here.
+     */
+    readonly info: Info;
+    /**
+     * When constructing insertable content,
+     * data that could be passed to the node's constructor can be used instead of an {@link Unhydrated} node
+     * iff implicitlyConstructable is true.
+     * @privateRemarks
+     * Currently the logic for traversing insertable content,
+     * both to build trees and to hydrate them does not defer to the schema classes to handle the policy,
+     * so if their constructors differ from what is supported, some cases will not work.
+     * Setting this to false adjusts the insertable types to disallow cases which could be impacted by these inconsistencies.
+     */
+    readonly implicitlyConstructable: ImplicitlyConstructable;
+}
+/**
+ * Kind of tree node.
+ * @remarks
+ * More kinds may be added over time, so do not assume this is an exhaustive set.
+ * @public
+ */
+export declare enum NodeKind {
+    /**
+     * A node which serves as a map, storing children under string keys.
+     */
+    Map = 0,
+    /**
+     * A node which serves as an array, storing children in an ordered sequence.
+     */
+    Array = 1,
+    /**
+     * A node which stores a heterogenous collection of children in named fields.
+     * @remarks
+     * Each field gets its own schema.
+     */
+    Object = 2,
+    /**
+     * A node which stores a single leaf value.
+     */
+    Leaf = 3
+}
+//# sourceMappingURL=treeNodeSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"treeNodeSchema.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/treeNodeSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE/D;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,CACzB,IAAI,SAAS,MAAM,GAAG,MAAM,EAC5B,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAChC,KAAK,GAAG,OAAO,EACf,MAAM,GAAG,KAAK,EACd,uBAAuB,SAAS,OAAO,GAAG,OAAO,EACjD,IAAI,GAAG,OAAO,IAEZ,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,EAAE,IAAI,CAAC,GAC7E,sBAAsB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,EAAE,IAAI,CAAC,CAAC;AAEpF;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB,CACtC,GAAG,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,EAChC,GAAG,CAAC,IAAI,SAAS,QAAQ,GAAG,QAAQ,EACpC,GAAG,CAAC,KAAK,GAAG,OAAO,EACnB,EAAE,CAAC,WAAW,GAAG,KAAK,EACtB,GAAG,CAAC,uBAAuB,SAAS,OAAO,GAAG,OAAO,EACrD,GAAG,CAAC,IAAI,GAAG,OAAO,CACjB,SAAQ,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,uBAAuB,EAAE,IAAI,CAAC;IACtE,MAAM,CAAC,IAAI,EAAE,WAAW,GAAG,KAAK,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,WAAW,mBAAmB,CACnC,GAAG,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,EAChC,GAAG,CAAC,IAAI,SAAS,QAAQ,GAAG,QAAQ,EACpC,GAAG,CAAC,KAAK,GAAG,OAAO,EACnB,EAAE,CAAC,WAAW,GAAG,KAAK,EACtB,GAAG,CAAC,uBAAuB,SAAS,OAAO,GAAG,OAAO,EACrD,GAAG,CAAC,IAAI,GAAG,OAAO,CACjB,SAAQ,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,uBAAuB,EAAE,IAAI,CAAC;IACtE;;;;;;OAMG;IACH,KAAK,IAAI,EAAE,WAAW,GAAG,gBAAgB,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;CAC9D;AACD;;;;;GAKG;AAEH,MAAM,WAAW,kBAAkB,CAClC,GAAG,CAAC,IAAI,SAAS,MAAM,EACvB,GAAG,CAAC,IAAI,SAAS,QAAQ,EACzB,GAAG,CAAC,uBAAuB,SAAS,OAAO,EAC3C,GAAG,CAAC,IAAI,GAAG,OAAO;IAElB;;;;;;;;;OASG;IACH,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAEpB;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAEpB;;;;;;;;;OASG;IACH,QAAQ,CAAC,uBAAuB,EAAE,uBAAuB,CAAC;CAC1D;AAED;;;;;GAKG;AACH,oBAAY,QAAQ;IACnB;;OAEG;IACH,GAAG,IAAA;IACH;;OAEG;IACH,KAAK,IAAA;IACL;;;;OAIG;IACH,MAAM,IAAA;IACN;;OAEG;IACH,IAAI,IAAA;CACJ"}

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

@@ -0,0 +1,35 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeKind = void 0;
+/**
+ * Kind of tree node.
+ * @remarks
+ * More kinds may be added over time, so do not assume this is an exhaustive set.
+ * @public
+ */
+var NodeKind;
+(function (NodeKind) {
+    /**
+     * A node which serves as a map, storing children under string keys.
+     */
+    NodeKind[NodeKind["Map"] = 0] = "Map";
+    /**
+     * A node which serves as an array, storing children in an ordered sequence.
+     */
+    NodeKind[NodeKind["Array"] = 1] = "Array";
+    /**
+     * A node which stores a heterogenous collection of children in named fields.
+     * @remarks
+     * Each field gets its own schema.
+     */
+    NodeKind[NodeKind["Object"] = 2] = "Object";
+    /**
+     * A node which stores a single leaf value.
+     */
+    NodeKind[NodeKind["Leaf"] = 3] = "Leaf";
+})(NodeKind || (exports.NodeKind = NodeKind = {}));
+//# sourceMappingURL=treeNodeSchema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"treeNodeSchema.js","sourceRoot":"","sources":["../../../src/simple-tree/core/treeNodeSchema.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AA2JH;;;;;GAKG;AACH,IAAY,QAmBX;AAnBD,WAAY,QAAQ;IACnB;;OAEG;IACH,qCAAG,CAAA;IACH;;OAEG;IACH,yCAAK,CAAA;IACL;;;;OAIG;IACH,2CAAM,CAAA;IACN;;OAEG;IACH,uCAAI,CAAA;AACL,CAAC,EAnBW,QAAQ,wBAAR,QAAQ,QAmBnB","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { InternalTreeNode, Unhydrated } from \"./types.js\";\n\n/**\n * Schema for a tree node.\n * @typeParam Name - The full (including scope) name/identifier for the schema.\n * @typeParam Kind - Which kind of node this schema is for.\n * @typeParam TNode - API for nodes that use this schema.\n * @typeParam TBuild - Data which can be used to construct an {@link Unhydrated} node of this type.\n * @typeParam Info - Data used when defining this schema.\n * @remarks\n * Captures the schema both as runtime data and compile time type information.\n * @sealed @public\n */\nexport type TreeNodeSchema<\n\tName extends string = string,\n\tKind extends NodeKind = NodeKind,\n\tTNode = unknown,\n\tTBuild = never,\n\tImplicitlyConstructable extends boolean = boolean,\n\tInfo = unknown,\n> =\n\t| TreeNodeSchemaClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>\n\t| TreeNodeSchemaNonClass<Name, Kind, TNode, TBuild, ImplicitlyConstructable, Info>;\n\n/**\n * Schema which is not a class.\n * @remarks\n * This is used for schema which cannot have their instances constructed using constructors, like leaf schema.\n * @privateRemarks\n * Non-class based schema can have issues with recursive types due to https://github.com/microsoft/TypeScript/issues/55832.\n * @sealed @public\n */\nexport interface TreeNodeSchemaNonClass<\n\tout Name extends string = string,\n\tout Kind extends NodeKind = NodeKind,\n\tout TNode = unknown,\n\tin TInsertable = never,\n\tout ImplicitlyConstructable extends boolean = boolean,\n\tout Info = unknown,\n> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {\n\tcreate(data: TInsertable): TNode;\n}\n\n/**\n * Tree node schema which is implemented using a class.\n * @remarks\n * Instances of this class are nodes in the tree.\n * This is also a constructor so that it can be subclassed.\n *\n * Using classes in this way allows introducing a named type and a named value at the same time, helping keep the runtime and compile time information together and easy to refer to un a uniform way.\n * Additionally, this works around https://github.com/microsoft/TypeScript/issues/55832 which causes similar patterns with less explicit types to infer \"any\" in the d.ts file.\n *\n * When sub-classing a a `TreeNodeSchemaClass`, some extra rules must be followed:\n *\n * - Only ever use a single class from the schema's class hierarchy within a document and its schema.\n * For example, if using {@link SchemaFactory.object} you can do:\n * ```typescript\n * // Recommended \"customizable\" object schema pattern.\n * class Good extends schemaFactory.object(\"A\", {\n * \texampleField: schemaFactory.number,\n * }) {\n * \tpublic exampleCustomMethod(): void {\n * \t\tthis.exampleField++;\n * \t}\n * }\n * ```\n * But should avoid:\n * ```typescript\n * // This by itself is ok, and opts into \"POJO mode\".\n * const base = schemaFactory.object(\"A\", {});\n * // This is a bad pattern since it leaves two classes in scope which derive from the same SchemaFactory defined class.\n * // If both get used, its an error!\n * class Invalid extends base {}\n * ```\n * - Do not modify the constructor input parameter types or values:\n * ```typescript\n * class Invalid extends schemaFactory.object(\"A\", {\n * \texampleField: schemaFactory.number,\n * }) {\n * \t// This Modifies the type of the constructor input.\n * \t// This is unsupported due to programmatic access to the constructor being used internally.\n * \tpublic constructor(a: number) {\n * \t\tsuper({ exampleField: a });\n * \t}\n * }\n * ```\n * @sealed @public\n */\nexport interface TreeNodeSchemaClass<\n\tout Name extends string = string,\n\tout Kind extends NodeKind = NodeKind,\n\tout TNode = unknown,\n\tin TInsertable = never,\n\tout ImplicitlyConstructable extends boolean = boolean,\n\tout Info = unknown,\n> extends TreeNodeSchemaCore<Name, Kind, ImplicitlyConstructable, Info> {\n\t/**\n\t * Constructs an {@link Unhydrated} node with this schema.\n\t * @remarks\n\t * This constructor is also used internally to construct hydrated nodes with a different parameter type.\n\t * Therefore, overriding this constructor with different argument types is not type-safe and is not supported.\n\t * @sealed\n\t */\n\tnew (data: TInsertable | InternalTreeNode): Unhydrated<TNode>;\n}\n/**\n * Data common to all tree node schema.\n * @remarks\n * Implementation detail of {@link TreeNodeSchema} which should be accessed instead of referring to this type directly.\n * @sealed @public\n */\n\nexport interface TreeNodeSchemaCore<\n\tout Name extends string,\n\tout Kind extends NodeKind,\n\tout ImplicitlyConstructable extends boolean,\n\tout Info = unknown,\n> {\n\t/**\n\t * Unique (within a document's schema) identifier used to associate nodes with their schema.\n\t * @remarks\n\t * This is used when encoding nodes, and when decoding nodes to re-associate them with the schema.\n\t * Since this decoding may happen in a different version of the application (or even a different application altogether),\n\t * this identifier should generally correspond to some specific semantics for the data (how to interpret the node with this identifier).\n\t * Any time the semantics change such that data would be misinterpreted if the old semantics were applied\n\t * (for example the units of a value are changed),\n\t * it is best practice to pick a new identifier.\n\t */\n\treadonly identifier: Name;\n\treadonly kind: Kind;\n\n\t/**\n\t * Data used to define this schema.\n\t *\n\t * @remarks\n\t * The format depends on the kind of node it is for.\n\t * For example, the \"object\" node kind could store the field schema here.\n\t */\n\treadonly info: Info;\n\n\t/**\n\t * When constructing insertable content,\n\t * data that could be passed to the node's constructor can be used instead of an {@link Unhydrated} node\n\t * iff implicitlyConstructable is true.\n\t * @privateRemarks\n\t * Currently the logic for traversing insertable content,\n\t * both to build trees and to hydrate them does not defer to the schema classes to handle the policy,\n\t * so if their constructors differ from what is supported, some cases will not work.\n\t * Setting this to false adjusts the insertable types to disallow cases which could be impacted by these inconsistencies.\n\t */\n\treadonly implicitlyConstructable: ImplicitlyConstructable;\n}\n\n/**\n * Kind of tree node.\n * @remarks\n * More kinds may be added over time, so do not assume this is an exhaustive set.\n * @public\n */\nexport enum NodeKind {\n\t/**\n\t * A node which serves as a map, storing children under string keys.\n\t */\n\tMap,\n\t/**\n\t * A node which serves as an array, storing children in an ordered sequence.\n\t */\n\tArray,\n\t/**\n\t * A node which stores a heterogenous collection of children in named fields.\n\t * @remarks\n\t * Each field gets its own schema.\n\t */\n\tObject,\n\t/**\n\t * A node which stores a single leaf value.\n\t */\n\tLeaf,\n}\n"]}

package/dist/simple-tree/{types.d.ts → core/types.d.ts}

@@ -3,8 +3,9 @@
  * Licensed under the MIT License.
  */
 import type { ErasedType } from "@fluidframework/core-interfaces";
-import { type TreeNodeSchema, type WithType, typeNameSymbol } from "./schemaTypes.js";
-import { type FlexTreeNode, type MapTreeNode } from "../feature-libraries/index.js";
+import { type TreeNodeSchemaClass } from "./treeNodeSchema.js";
+import { type WithType, typeNameSymbol, type typeSchemaSymbol } from "./withType.js";
+import { type FlexTreeNode } from "../../feature-libraries/index.js";
 /**
  * Type alias to document which values are un-hydrated.
  *
@@ -117,8 +118,15 @@ export declare abstract class TreeNode implements WithType {
      * Adds a type symbol for stronger typing.
      * @privateRemarks
      * Subclasses provide more specific strings for this to get strong typing of otherwise type compatible nodes.
+     * @deprecated Use {@link typeSchemaSymbol} instead.
      */
     abstract get [typeNameSymbol](): string;
+    /**
+     * Adds a type symbol for stronger typing.
+     * @privateRemarks
+     * Subclasses provide more specific strings for this to get strong typing of otherwise type compatible nodes.
+     */
+    abstract get [typeSchemaSymbol](): TreeNodeSchemaClass;
     /**
      * Provides `instanceof` support for testing if a value is a `TreeNode`.
      * @remarks
@@ -135,8 +143,20 @@ export declare abstract class TreeNode implements WithType {
      * Despite type-only export, this functionality is available outside the package since it is inherited by subclasses.
      */
     static [Symbol.hasInstance]<TSchema extends abstract new (...args: any[]) => TreeNode>(this: TSchema, value: unknown): value is InstanceType<TSchema>;
-    protected constructor();
+    /**
+     * TreeNodes must extend schema classes created by SchemaFactory, and therefore this constructor should not be invoked directly by code outside this package.
+     * @privateRemarks
+     * `token` must be the {@link privateToken} value, which is not package exported.
+     * This is used to detect invalid subclasses.
+     *
+     * All valid subclass should use {@link TreeNodeValid}, but this code doesn't directly reference it to avoid cyclic dependencies.
+     */
+    protected constructor(token: unknown);
 }
+/**
+ * `token` to pass to {@link TreeNode}'s constructor used to detect invalid subclasses.
+ */
+export declare const privateToken: {};
 /**
  * Check if the prototype derived's prototype chain contains `base`.
  * @param derived - prototype to check
@@ -144,73 +164,6 @@ export declare abstract class TreeNode implements WithType {
  * @returns true iff `base` is in the prototype chain starting at `derived`.
  */
 export declare function inPrototypeChain(derived: object | null, base: object): boolean;
-/**
- * Class which all {@link TreeNode}s must extend.
- * Since this is not exported, it allows robust detection of attempts to create TreeNodes which do not go through SchemaFactory which is the only place which exposes classes that extend this.
- *
- * This has static members which schema classes can override to provide schema specific functionality.
- * These static members are only intended to be used / overridden by code within this package, and are used by the various node kinds.
- * Access to these static members has to be done via `this.constructor.staticMember` to support the overrides, and thus can only be used in the constructor, after the base constructor has been invoked.
- */
-export declare abstract class TreeNodeValid<TInput> extends TreeNode {
-    /**
-     * Schema classes can override this to control what happens at the end of the constructor.
-     * The return value from this is returned from the constructor, allowing substituting a proxy if desired.
-     *
-     * This is not simply done in the derived constructor to enable:
-     * - this class to access the value which is being returned before it's returned from the constructor.
-     * - the derived class to be provided the input `FlexTreeNode` without relying on a field on the node to hold it.
-     */
-    protected static prepareInstance<T>(this: typeof TreeNodeValid<T>, instance: TreeNodeValid<T>, input: FlexTreeNode): TreeNodeValid<T>;
-    /**
-     * Schema classes must override to provide an implementation of RawTreeNode construction.
-     */
-    protected static buildRawNode<T>(this: typeof TreeNodeValid<T>, instance: TreeNodeValid<T>, input: T): MapTreeNode;
-    /**
-     * Schema classes can override to provide a callback that is called once when the first node is constructed.
-     * This is a good place to perform extra validation and cache schema derived data needed for the implementation of the node.
-     */
-    protected static oneTimeSetup<T>(this: typeof TreeNodeValid<T>): void;
-    /**
-     * The most derived constructor (the one invoked with the `new` operator, not a parent class constructor invoked with as `super`) used to construct an instance of this type.
-     * @remarks
-     * Captured when an instance is constructed.
-     *
-     * Used to ensure that some derived class (which must override this member, defaulting it to `undefined`) is only instantiated with a single "most derived" class (the constructor actually invoked the the user with `new`).
-     *
-     * Typically this is override in the class that statically implements {@link TreeNodeSchema} to enforce that all nodes using that schema use the same class and not different subclasses of it.
-     *
-     * Also used to detect if oneTimeSetup has run.
-     *
-     * @privateRemarks
-     * This defaults to "default", which is used to trigger an error if not overridden in the derived class.
-     *
-     * The value of this on TreeNodeValid must only be overridden by base classes and never modified.
-     * Ways to enforce this immutability prevent it from being overridden,
-     * so code modifying constructorCached should be extra careful to avoid accidentally modifying the base/inherited value.
-     */
-    protected static constructorCached: MostDerivedData | "default" | undefined;
-    /**
-     * Indicate that `this` is the most derived version of a schema, and thus the only one allowed to be used (other than by being subclassed a single time).
-     */
-    static markMostDerived(this: typeof TreeNodeValid & TreeNodeSchema): MostDerivedData;
-    constructor(input: TInput | InternalTreeNode);
-}
-/**
- * Data cached about the most derived type in a schema's class hierarchy.
- * @remarks
- * The most derived type is the only one allowed to be referenced by other schema or constructed as a node.
- * It has to be discovered lazily (when a node is constructed or when a {@link TreeViewConfiguration} is made),
- * since JavaScript provides no way to find derived classes, or inject static class initialization time logic into base classes.
- * Additionally since schema can reference other schema through lazy references which might be forward or recursive references,
- * this can not be evaluated for one schema when referenced by another schema.
- *
- * See {@link TreeNodeValid.constructorCached} and {@link TreeNodeValid.markMostDerived}.
- */
-export interface MostDerivedData {
-    readonly constructor: typeof TreeNodeValid & TreeNodeSchema;
-    oneTimeInitialized: boolean;
-}
 /**
  * A node type internal to `@fluidframework/tree`.
  * @remarks

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE,OAAO,EAAY,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAEzE,OAAO,EAAE,KAAK,QAAQ,EAAE,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAErF,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAErF;;;;;;;;GAQG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,gBAAgB;IAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB;;;;;;;;;;;;;;;OAeG;IACH,WAAW,IAAI,IAAI,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,8BAAsB,QAAS,YAAW,QAAQ;;IA6BjD;;;;;OAKG;IAEH,aAAoB,CAAC,cAAc,CAAC,IAAI,MAAM,CAAC;IAE/C;;;;OAIG;IACH,aAAoB,CAAC,gBAAgB,CAAC,IAAI,mBAAmB,CAAC;IAE9D;;;;;;OAMG;WACW,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ;IAErE;;;;;;OAMG;WACW,CAAC,MAAM,CAAC,WAAW,CAAC,CACjC,OAAO,SAAS,QAAQ,MACvB,GAAG,IAAI,EAAE,GAAG,EAAE,KACV,QAAQ,EACZ,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAAC,OAAO,CAAC;IAahE;;;;;;;OAOG;IACH,SAAS,aAAa,KAAK,EAAE,OAAO;CAKpC;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,IAAK,CAAC;AAE/B;;;;;GAKG;AAEH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAS9E;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAChB,SAAQ,UAAU,CAAC,uCAAuC,CAAC;CAAG;AAE/D,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,GAAG,YAAY,CAGnE"}