@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/lib/util/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/util/utils.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\";\nimport { Type } from \"@sinclair/typebox\";\nimport structuredClone from \"@ungap/structured-clone\";\nimport {\n\tgenerateStableId as runtimeGenerateStableId,\n\tassertIsStableId,\n\tStableId,\n} from \"@fluidframework/id-compressor\";\n\n/**\n * Subset of Map interface.\n */\nexport interface MapGetSet<K, V> {\n\tget(key: K): V | undefined;\n\tset(key: K, value: V): void;\n}\n\n/**\n * Make all transitive properties in T readonly\n */\nexport type RecursiveReadonly<T> = {\n\treadonly [P in keyof T]: RecursiveReadonly<T[P]>;\n};\n\n/**\n * Remove `readonly` from all fields.\n */\nexport type Mutable<T> = { -readonly [P in keyof T]: T[P] };\n\n/**\n * Make all field required and omits fields whose ony valid value would be `undefined`.\n * This is analogous to `Required<T>` except it tolerates 'optional undefined'.\n */\nexport type Populated<T> = {\n\t[P in keyof T as Exclude<P, T[P] extends undefined ? P : never>]-?: T[P];\n};\n\n/**\n * Casts a readonly object to a mutable one.\n * Better than casting to `Mutable<Foo>` because it doesn't risk casting a non-`Foo` to a `Mutable<Foo>`.\n * @param readonly - The object with readonly fields.\n * @returns The same object but with a type that makes all fields mutable.\n */\nexport function asMutable<T>(readonly: T): Mutable<T> {\n\treturn readonly as Mutable<T>;\n}\n\nexport const clone = structuredClone;\n\n/**\n * @internal\n */\nexport function fail(message: string): never {\n\tthrow new Error(message);\n}\n\n/**\n * Checks whether or not the given object is a `readonly` array.\n *\n * Note that this does NOT indicate if a given array should be treated as readonly.\n * This instead indicates if an object is an Array, and is typed to tolerate the readonly case.\n */\nexport function isReadonlyArray<T>(x: readonly T[] | unknown): x is readonly T[] {\n\t// `Array.isArray()` does not properly narrow `readonly` array types by itself,\n\t// so we wrap it in this type guard. This may become unnecessary if/when\n\t// https://github.com/microsoft/TypeScript/issues/17002 is resolved.\n\treturn Array.isArray(x);\n}\n\n/**\n * Creates and populates a new array.\n * @param size - The size of the array to be created.\n * @param filler - Callback for populating the array with a value for a given index\n */\nexport function makeArray<T>(size: number, filler: (index: number) => T): T[] {\n\tconst array = [];\n\tfor (let i = 0; i < size; ++i) {\n\t\tarray.push(filler(i));\n\t}\n\treturn array;\n}\n\n/**\n * Compares two sets using callbacks.\n * Early returns on first false comparison.\n *\n * @param a - One Set.\n * @param b - The other Set.\n * @param aExtra - Called for items in `a` but not `b`.\n * @param bExtra - Called for items in `b` but not `a`.\n * @param same - Called for items in `a` and `b`.\n * @returns false iff any of the call backs returned false.\n */\nexport function compareSets<T>({\n\ta,\n\tb,\n\taExtra,\n\tbExtra,\n\tsame,\n}: {\n\ta: ReadonlySet<T> | ReadonlyMap<T, unknown>;\n\tb: ReadonlySet<T> | ReadonlyMap<T, unknown>;\n\taExtra?: (t: T) => boolean;\n\tbExtra?: (t: T) => boolean;\n\tsame?: (t: T) => boolean;\n}): boolean {\n\tfor (const item of a.keys()) {\n\t\tif (!b.has(item)) {\n\t\t\tif (aExtra && !aExtra(item)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t} else {\n\t\t\tif (same && !same(item)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t}\n\tfor (const item of b.keys()) {\n\t\tif (!a.has(item)) {\n\t\t\tif (bExtra && !bExtra(item)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t}\n\treturn true;\n}\n\n/**\n * Retrieve a value from a map with the given key, or create a new entry if the key is not in the map.\n * @param map - The map to query/update\n * @param key - The key to lookup in the map\n * @param defaultValue - a function which returns a default value. This is called and used to set an initial value for the given key in the map if none exists\n * @returns either the existing value for the given key, or the newly-created value (the result of `defaultValue`)\n */\nexport function getOrCreate<K, V>(map: MapGetSet<K, V>, key: K, defaultValue: (key: K) => V): V {\n\tlet value = map.get(key);\n\tif (value === undefined) {\n\t\tvalue = defaultValue(key);\n\t\tmap.set(key, value);\n\t}\n\treturn value;\n}\n\n/**\n * Utility for dictionaries whose values are lists.\n * Gets the list associated with the provided key, if it exists.\n * Otherwise, creates an entry with an empty list, and returns that list.\n */\nexport function getOrAddEmptyToMap<K, V>(map: MapGetSet<K, V[]>, key: K): V[] {\n\tlet collection = map.get(key);\n\tif (collection === undefined) {\n\t\tcollection = [];\n\t\tmap.set(key, collection);\n\t}\n\treturn collection;\n}\n\n/**\n * Map one iterable to another by transforming each element one at a time\n * @param iterable - the iterable to transform\n * @param map - the transformation function to run on each element of the iterable\n * @returns a new iterable of elements which have been transformed by the `map` function\n */\nexport function* mapIterable<T, U>(iterable: Iterable<T>, map: (t: T) => U): Iterable<U> {\n\tfor (const t of iterable) {\n\t\tyield map(t);\n\t}\n}\n\n/**\n * Returns an iterable of tuples containing pairs of elements from the given iterables\n * @param iterableA - an iterable to zip together with `iterableB`\n * @param iterableB - an iterable to zip together with `iterableA`\n * @returns in iterable of tuples of elements zipped together from `iterableA` and `iterableB`.\n * If the input iterables are of different lengths, then the extra elements in the longer will be ignored.\n */\nexport function* zipIterables<T, U>(\n\titerableA: Iterable<T>,\n\titerableB: Iterable<U>,\n): Iterable<[T, U]> {\n\tconst iteratorA = iterableA[Symbol.iterator]();\n\tconst iteratorB = iterableB[Symbol.iterator]();\n\tfor (\n\t\tlet nextA = iteratorA.next(), nextB = iteratorB.next();\n\t\tnextA.done !== true && nextB.done !== true;\n\t\tnextA = iteratorA.next(), nextB = iteratorB.next()\n\t) {\n\t\tyield [nextA.value, nextB.value];\n\t}\n}\n\n/**\n * Use for Json compatible data.\n *\n * Note that this does not robustly forbid non json comparable data via type checking,\n * but instead mostly restricts access to it.\n * @internal\n */\nexport type JsonCompatible =\n\t| string\n\t| number\n\t| boolean\n\t// eslint-disable-next-line @rushstack/no-new-null\n\t| null\n\t| JsonCompatible[]\n\t| JsonCompatibleObject;\n\n/**\n * Use for Json object compatible data.\n *\n * Note that this does not robustly forbid non json comparable data via type checking,\n * but instead mostly restricts access to it.\n * @internal\n */\nexport type JsonCompatibleObject = { [P in string]?: JsonCompatible };\n\n/**\n * Use for readonly view of Json compatible data.\n *\n * Note that this does not robustly forbid non json comparable data via type checking,\n * but instead mostly restricts access to it.\n * @internal\n */\nexport type JsonCompatibleReadOnly =\n\t| string\n\t| number\n\t| boolean\n\t// eslint-disable-next-line @rushstack/no-new-null\n\t| null\n\t| readonly JsonCompatibleReadOnly[]\n\t| { readonly [P in string]?: JsonCompatibleReadOnly };\n\n/**\n * @remarks TODO: Audit usage of this type in schemas, evaluating whether it is necessary and performance\n * of alternatives.\n *\n * True \"arbitrary serializable data\" is probably fine, but some persisted types declarations might be better\n * expressed using composition of schemas for runtime validation, even if we don't think making the types\n * generic is worth the maintenance cost.\n */\nexport const JsonCompatibleReadOnlySchema = Type.Any();\n\n/**\n * Returns if a particular json compatible value is an object.\n * Does not include `null` or arrays.\n */\nexport function isJsonObject(\n\tvalue: JsonCompatibleReadOnly,\n): value is { readonly [P in string]?: JsonCompatibleReadOnly } {\n\treturn typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n/**\n * Verifies that the supplied indices are valid within the supplied array.\n * @param startIndex - The starting index in the range. Must be in [0, length).\n * @param endIndex - The ending index in the range. Must be within (start, length].\n * @param array - The array the indices refer to\n */\nexport function assertValidRangeIndices(\n\tstartIndex: number,\n\tendIndex: number,\n\tarray: { readonly length: number },\n) {\n\tassert(endIndex >= startIndex, 0x79c /* Range indices are malformed. */);\n\tassertValidIndex(startIndex, array, false);\n\tassertValidIndex(endIndex, array, true);\n}\n\nexport function assertValidIndex(\n\tindex: number,\n\tarray: { readonly length: number },\n\tallowOnePastEnd: boolean = false,\n) {\n\tassertNonNegativeSafeInteger(index);\n\tif (allowOnePastEnd) {\n\t\tassert(index <= array.length, 0x378 /* index must be less than or equal to length */);\n\t} else {\n\t\tassert(index < array.length, 0x379 /* index must be less than length */);\n\t}\n}\n\nexport function assertValidRange(\n\t{ start, end }: { start: number; end: number },\n\tarray: { readonly length: number },\n) {\n\tassertNonNegativeSafeInteger(start);\n\tassertNonNegativeSafeInteger(end);\n\tassert(end <= array.length, 0x79d /* Range end must be less than or equal to length */);\n\tassert(start <= end, 0x79e /* Range start must be less than or equal to range start */);\n}\n\nexport function assertNonNegativeSafeInteger(index: number) {\n\tassert(Number.isSafeInteger(index), 0x376 /* index must be an integer */);\n\tassert(index >= 0, 0x377 /* index must be non-negative */);\n}\n\n/**\n * Assume that `TInput` is a `TAssumeToBe`.\n *\n * @remarks\n * This is useful in generic code when it is impractical (or messy)\n * to to convince the compiler that a generic type `TInput` will extend `TAssumeToBe`.\n * In these cases `TInput` can be replaced with `Assume<TInput, TAssumeToBe>` to allow compilation of the generic code.\n * When the generic code is parameterized with a concrete type, if that type actually does extend `TAssumeToBe`,\n * it will behave like `TInput` was used directly.\n *\n * @internal\n */\nexport type Assume<TInput, TAssumeToBe> = [TInput] extends [TAssumeToBe] ? TInput : TAssumeToBe;\n\n/**\n * The counter used to generate deterministic stable ids for testing purposes.\n */\nlet deterministicStableIdCount: number | undefined;\n\n/**\n * Runs `f` with {@link generateStableId} altered to return sequential StableIds starting as a fixed seed.\n * Used to make test logic that uses {@link generateStableId} deterministic.\n *\n * @remarks Only use this function for testing purposes.\n *\n * @example\n *\n * ```typescript\n * function f() {\n *    const id = generateStableId();\n *    ...\n * }\n * const result = useDeterministicStableId(f());\n * ```\n */\nexport function useDeterministicStableId<T>(f: () => T): T {\n\tassert(\n\t\tdeterministicStableIdCount === undefined,\n\t\t0x6ce /* useDeterministicStableId cannot be nested */,\n\t);\n\tdeterministicStableIdCount = 1;\n\ttry {\n\t\treturn f();\n\t\t// Since this is intended to be used by tests, and test runners often recover from exceptions to run more tests,\n\t\t// clean this up with a finally block to reduce risk of breaking unrelated tests after a failure.\n\t} finally {\n\t\tdeterministicStableIdCount = undefined;\n\t}\n}\n\nexport async function useAsyncDeterministicStableId<T>(f: () => Promise<T>): Promise<T> {\n\tassert(\n\t\tdeterministicStableIdCount === undefined,\n\t\t0x79f /* useAsyncDeterministicStableId cannot be nested */,\n\t);\n\tdeterministicStableIdCount = 1;\n\ttry {\n\t\treturn await f();\n\t\t// Since this is intended to be used by tests, and test runners often recover from exceptions to run more tests,\n\t\t// clean this up with a finally block to reduce risk of breaking unrelated tests after a failure.\n\t} finally {\n\t\tdeterministicStableIdCount = undefined;\n\t}\n}\n\n/**\n * Generates a random StableId.\n *\n * For test usage desiring deterministic results, see {@link useDeterministicStableId}.\n */\nexport function generateStableId(): StableId {\n\tif (deterministicStableIdCount !== undefined) {\n\t\tassert(\n\t\t\tdeterministicStableIdCount < 281_474_976_710_656,\n\t\t\t0x6cf /* The maximum valid value for deterministicStableIdCount is 16^12 */,\n\t\t);\n\t\t// Tried to generate a unique id prefixing it with the word 'beef'\n\t\treturn assertIsStableId(\n\t\t\t`beefbeef-beef-4000-8000-${(deterministicStableIdCount++)\n\t\t\t\t.toString(16)\n\t\t\t\t.padStart(12, \"0\")}`,\n\t\t);\n\t}\n\treturn runtimeGenerateStableId();\n}\n\n/**\n * Convert an object into a Map.\n *\n * This function must only be used with objects specifically intended to encode map like information.\n * The only time such objects should be used is for encoding maps as object literals to allow for developer ergonomics or JSON compatibility.\n * Even those two use-cases need to be carefully considered as using objects as maps can have a lot of issues\n * (including but not limited to unintended access to __proto__ and other non-owned keys).\n * This function helps these few cases get into using an actual map in as safe of was as is practical.\n */\nexport function objectToMap<MapKey extends string | number | symbol, MapValue>(\n\tobjectMap: Record<MapKey, MapValue>,\n): Map<MapKey, MapValue> {\n\tconst map = new Map<MapKey, MapValue>();\n\t// This function must only be used with objects specifically intended to encode map like information.\n\tfor (const key of Object.keys(objectMap)) {\n\t\tconst element = objectMap[key as MapKey];\n\t\tmap.set(key as MapKey, element);\n\t}\n\treturn map;\n}\n\n/**\n * Convert an object used as a map into a new object used like a map.\n *\n * @remarks\n * This function must only be used with objects specifically intended to encode map like information.\n * The only time such objects should be used is for encoding maps as object literals to allow for developer ergonomics or JSON compatibility.\n * Even those two use-cases need to be carefully considered as using objects as maps can have a lot of issues\n * (including but not limited to unintended access to __proto__ and other non-owned keys).\n * {@link objectToMap} helps these few cases get into using an actual map in as safe of a way as is practical.\n */\nexport function transformObjectMap<MapKey extends string | number | symbol, MapValue, NewMapValue>(\n\tobjectMap: Record<MapKey, MapValue>,\n\ttransformer: (value: MapValue, key: MapKey) => NewMapValue,\n): Record<MapKey, MapValue> {\n\tconst output: Record<MapKey, MapValue> = Object.create(null);\n\t// This function must only be used with objects specifically intended to encode map like information.\n\tfor (const key of Object.keys(objectMap)) {\n\t\tconst element = objectMap[key as MapKey];\n\t\tObject.defineProperty(output, key, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\twritable: true,\n\t\t\tvalue: transformer(element, key as MapKey),\n\t\t});\n\t}\n\treturn output;\n}\n\n/**\n * Make an inverted copy of a map.\n *\n * @returns a map which can look up the keys from the values of the original map.\n */\nexport function invertMap<Key, Value>(input: Map<Key, Value>): Map<Value, Key> {\n\tconst result = new Map<Value, Key>(mapIterable(input, ([key, value]) => [value, key]));\n\tassert(result.size === input.size, \"all values in a map must be unique to invert it\");\n\treturn result;\n}\n\n/**\n * Returns the value from `set` if it contains exactly one item, otherwise `undefined`.\n * @internal\n */\nexport function oneFromSet<T>(set: ReadonlySet<T> | undefined): T | undefined {\n\tif (set === undefined) {\n\t\treturn undefined;\n\t}\n\tif (set.size !== 1) {\n\t\treturn undefined;\n\t}\n\tfor (const item of set) {\n\t\treturn item;\n\t}\n}\n\n/**\n * Type with a name describing what it is.\n * Typically used with values (like schema) that can be stored in a map, but in some representations have their name/key as a field.\n * @internal\n */\nexport interface Named<TName> {\n\treadonly name: TName;\n}\n\n/**\n * Order {@link Named} objects by their name.\n * @internal\n */\nexport function compareNamed(a: Named<string>, b: Named<string>): -1 | 0 | 1 {\n\tif (a.name < b.name) {\n\t\treturn -1;\n\t}\n\tif (a.name > b.name) {\n\t\treturn 1;\n\t}\n\treturn 0;\n}\n\n/**\n * Placeholder for `Symbol.dispose`.\n *\n * Replace this with `Symbol.dispose` when it is available.\n * @beta\n */\nexport const disposeSymbol: unique symbol = Symbol(\"Symbol.dispose placeholder\");\n\n/**\n * An object with an explicit lifetime that can be ended.\n * @privateRemarks\n * TODO: align this with core-utils/IDisposable and {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#using-declarations-and-explicit-resource-management| TypeScript's Disposable}.\n * @beta\n */\nexport interface IDisposable {\n\t/**\n\t * Call to end the lifetime of this object.\n\t *\n\t * It is invalid to use this object after this,\n\t * except for operations which explicitly document they are valid after disposal.\n\t *\n\t * @remarks\n\t * May cleanup resources retained by this object.\n\t * Often includes un-registering from events and thus preventing other objects from retaining a reference to this indefinably.\n\t *\n\t * Usually the only operations allowed after disposal are querying if an object is already disposed,\n\t * but this can vary between implementations.\n\t */\n\t[disposeSymbol](): void;\n}\n\n/**\n * Capitalize a string.\n */\nexport function capitalize<S extends string>(s: S): Capitalize<S> {\n\t// To avoid splitting characters which are made of multiple UTF-16 code units,\n\t// use iteration instead of indexing to separate the first character.\n\tconst iterated = s[Symbol.iterator]().next();\n\tif (iterated.done === true) {\n\t\t// Empty string case.\n\t\treturn \"\" as Capitalize<S>;\n\t}\n\n\treturn (iterated.value.toUpperCase() + s.slice(iterated.value.length)) as Capitalize<S>;\n}\n\n/**\n * Compares strings lexically to form a strict partial ordering.\n */\nexport function compareStrings<T extends string>(a: T, b: T): number {\n\treturn a > b ? 1 : a === b ? 0 : -1;\n}\n"]}

package/package.json

@@ -0,0 +1,129 @@
+{
+  "name": "@fluidframework/tree",
+  "version": "2.0.0-dev-rc.1.0.0.224419",
+  "description": "Tree",
+  "homepage": "https://fluidframework.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/microsoft/FluidFramework.git",
+    "directory": "experimental/dds/tree2"
+  },
+  "license": "MIT",
+  "author": "Microsoft and contributors",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "module": "lib/index.js",
+  "types": "dist/index.d.ts",
+  "c8": {
+    "all": true,
+    "cache-dir": "nyc/.cache",
+    "exclude": [
+      "src/test/**/*.*ts",
+      "dist/test/**/*.*js"
+    ],
+    "exclude-after-remap": false,
+    "include": [
+      "src/**/*.*ts",
+      "dist/**/*.*js"
+    ],
+    "report-dir": "nyc/report",
+    "reporter": [
+      "cobertura",
+      "html",
+      "text"
+    ],
+    "temp-directory": "nyc/.nyc_output"
+  },
+  "dependencies": {
+    "@fluid-internal/client-utils": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluidframework/container-runtime": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluidframework/core-interfaces": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluidframework/core-utils": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluidframework/datastore-definitions": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluidframework/id-compressor": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluidframework/protocol-definitions": "^3.1.0-223007",
+    "@fluidframework/runtime-definitions": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluidframework/runtime-utils": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluidframework/shared-object-base": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluidframework/telemetry-utils": "2.0.0-dev-rc.1.0.0.224419",
+    "@sinclair/typebox": "^0.29.4",
+    "@ungap/structured-clone": "^1.2.0",
+    "sorted-btree": "^1.8.0",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@fluid-private/stochastic-test-utils": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluid-private/test-dds-utils": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluid-private/test-drivers": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluid-tools/benchmark": "^0.48.0",
+    "@fluid-tools/build-cli": "0.29.0-222379",
+    "@fluidframework/build-common": "^2.0.3",
+    "@fluidframework/build-tools": "0.29.0-222379",
+    "@fluidframework/container-definitions": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluidframework/container-loader": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluidframework/eslint-config-fluid": "^3.1.0",
+    "@fluidframework/mocha-test-setup": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluidframework/test-runtime-utils": "2.0.0-dev-rc.1.0.0.224419",
+    "@fluidframework/test-utils": "2.0.0-dev-rc.1.0.0.224419",
+    "@microsoft/api-extractor": "^7.38.3",
+    "@types/diff": "^3.5.1",
+    "@types/easy-table": "^0.0.32",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^18.19.0",
+    "@types/ungap__structured-clone": "^0.3.0",
+    "@types/uuid": "^9.0.2",
+    "ajv": "^8.12.0",
+    "ajv-formats": "^2.1.1",
+    "c8": "^7.7.1",
+    "cross-env": "^7.0.3",
+    "dependency-cruiser": "^14.1.0",
+    "diff": "^3.5.0",
+    "easy-table": "^1.1.1",
+    "eslint": "~8.50.0",
+    "eslint-config-prettier": "~9.0.0",
+    "mocha": "^10.2.0",
+    "mocha-json-output-reporter": "^2.0.1",
+    "mocha-multi-reporters": "^1.5.1",
+    "moment": "^2.21.0",
+    "prettier": "~3.0.3",
+    "rimraf": "^4.4.0",
+    "typescript": "~5.1.6"
+  },
+  "typeValidation": {
+    "disabled": true,
+    "broken": {}
+  },
+  "scripts": {
+    "bench": "mocha --timeout 999999 --perfMode --parentProcess --fgrep @Benchmark --reporter @fluid-tools/benchmark/dist/MochaReporter.js",
+    "bench:profile": "mocha --v8-prof --v8-logfile=profile.log --v8-no-logfile-per-isolate --timeout 999999 --perfMode --fgrep @Benchmark --reporter @fluid-tools/benchmark/dist/MochaReporter.js && node --prof-process profile.log > profile.txt && rimraf profile.log && echo See results in profile.txt",
+    "build": "fluid-build . --task build",
+    "build:commonjs": "fluid-build . --task commonjs",
+    "build:compile": "fluid-build . --task compile",
+    "build:docs": "api-extractor run --local",
+    "build:esnext": "tsc --project ./tsconfig.esnext.json",
+    "build:test": "tsc --project ./src/test/tsconfig.json",
+    "check:release-tags": "api-extractor run --local --config ./api-extractor-lint.json",
+    "ci:build:docs": "api-extractor run",
+    "clean": "rimraf --glob dist lib \"**/*.tsbuildinfo\" \"**/*.build.log\" _api-extractor-temp nyc",
+    "depcruise": "depcruise src/ --ignore-known",
+    "depcruise:regen-known-issues": "depcruise-baseline src",
+    "eslint": "eslint --format stylish src",
+    "eslint:fix": "eslint --format stylish src --fix --fix-type problem,suggestion,layout",
+    "format": "npm run prettier:fix",
+    "lint": "npm run prettier && npm run check:release-tags && npm run eslint",
+    "lint:fix": "npm run prettier:fix && npm run eslint:fix",
+    "prettier": "prettier --check . --cache --ignore-path ../../../.prettierignore",
+    "prettier:fix": "prettier --write . --cache --ignore-path ../../../.prettierignore",
+    "test": "npm run test:mocha",
+    "test:benchmark:report": "mocha --exit --perfMode --parentProcess --fgrep @Benchmark --reporter @fluid-tools/benchmark/dist/MochaReporter.js --timeout 60000",
+    "test:coverage": "c8 npm test",
+    "test:mocha": "mocha",
+    "test:mocha:verbose": "cross-env FLUID_TEST_VERBOSE=1 npm run test:mocha",
+    "test:snapshots": "cross-env MOCHA_SPEC=./dist/test/snapshots mocha",
+    "test:snapshots:regen": "cross-env MOCHA_SPEC=./dist/test/snapshots mocha -- --snapshot",
+    "test:stress": "cross-env FUZZ_TEST_COUNT=20 FUZZ_STRESS_RUN=true mocha --ignore \"dist/test/memory/**/*\" --recursive \"dist/test/**/*.spec.js\" -r @fluidframework/mocha-test-setup",
+    "tsc": "tsc",
+    "typetests:gen": "fluid-type-test-generator",
+    "typetests:prepare": "flub typetests --dir . --reset --previous --normalize"
+  }
+}

package/prettier.config.cjs

@@ -0,0 +1,8 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+module.exports = {
+	...require("@fluidframework/build-common/prettier.config.cjs"),
+};

package/src/class-tree/README.md

@@ -0,0 +1,67 @@
+# class-tree
+
+This is a temporary directory containing a second implementation of the tree types from simple-tree, but built on-top of a customized schema system optimized for this specific tree API.
+
+The main differences from the old schema system (SchemaBuilder and its related types):
+
+1. The new schema system is layered on-top of internal one without leaking all the types from it into the public API.
+   Wrappers, type erasure and casting in the implementation are used as required to accomplish this.
+2. The new system is designed from scratch to work at the same abstraction layer and data model as used in simple-tree.
+   This means concepts like `List` are supported in a first class way, and the focus is on kinds of nodes (List, Object, Map), and not on FieldKinds.
+   No extra special cases and carve-outs are needed to support cases the internal data-model supports:
+   tests for those cases will simply not use this wrapper layer and can use the pre-existing schema builder instead.
+3. Schema are classes, and the instance types of those classes are what gets exposed in the tree API.
+   This has many benefits:
+    1. Users don't have to use `typeof` or invoke any type meta-functions to get the node types they want to pass around: just use the class/schema name as the type.
+       This replaces `Typed<typeof myNodeSchema>` with just `MyNode`.
+    2. Recursive schema work in `d.ts`` files due to use of classes.
+       See [Generated d.ts includes implicit any for recursive types](microsoft/TypeScript#55832).
+    3. Intellisense is much cleaner when referring to types defined in schema:
+       it just uses the class name (for example `MyNode`) when referring to the node type or `typeof MyNode` when referring to the schema's type.
+       These simplifications are what resolve the `d.ts`` issue noted above with recursive types.
+    4. Normal JS/TS type narrowing with `instanceof` can be used with schema defined types.
+    5. It's possible to add view/session local state to instances as properties, as well as adding methods by just putting them in the class like any other class.
+
+Currently this implementation exposes the prototypes from these classes: this impacts some generic object based code.
+For example, this probably impacts Node's deep equals as follows:
+
+1. Two trees with the same "shape" but different types no longer compare equal.
+2. Trees no longer compare equal to plain objects with no prototypes.
+
+## Limitations
+
+Fields allowing `Any` can not be supported due to the requirement to traverse all types from the root.
+
+Returned classes from factory cannot have any private or protected members due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/36060).
+This means getting nominal typing (non-structural typing) of node will require explicit members (like a strongly typed schema or type name symbol) if nominal typing is desired.
+Private data can still be stored using `#` private fields, or via weak keyed maps or under symbols.
+Even regular private and protected fields can be used in the implementation and casts away from the type returned by the factory,
+though doing this risks name collisions with user added members.
+
+Comparing trees to object literals (for example in tests), will require a dedicated tree comparison function and/or comparing to unhydrated nodes (and implementing more APIs for them) instead of plain literals.
+
+Adding custom constructors to the schema classes is likely to break them, though static builders (like "create") can be added just fine.
+
+### Insertable content
+
+Currently the type allowed within InsertableContent comes from `InsertableTypedNode`.
+This type includes `NodeBuilderData<T>`, which extracts the type from the constructor's parameter.
+This allows changing what types can be used to build a node in a single place, however the logic to process that data is not part of the class currently.
+This means that changing the types can easily lead to cases where runtime behavior of parsing or hydrating the `InsertableTypedNode` might not align with the types.
+Directing the logic back into the schema for implementation would make extending the set of node kinds and adjusting constructor parameters much more encapsulated.
+
+### Missing Tree Comparison test utility
+
+There is currently no good API to dump tree content or compare it which includes all persisted data (including types).
+Related to this there is also no good way to round trip a tree through an external system.
+The lower-level APIs have solutions, but there currently aren't any for the simple/class tree layer.
+
+### Recursive types are still very sketchy
+
+Recursive objects can work ok, see notes on `SchemaFactory.fixRecursiveReference`.
+This does not seem to fix directly recursive lists or maps (but some cases of co-recursive through object does seem to work).
+Experiments are ongoing for how to fix them.
+
+## Ideas to consider in the future
+
+1. allow class schema to override methods to provide hooks. For example "serializeSessionState", to allow persisting things like selection. Maybe support via decorator? override methods for events?

package/src/class-tree/index.ts

@@ -0,0 +1,43 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export { ITree, TreeView, TreeConfiguration, WrapperTreeView } from "./tree";
+export {
+	TreeNodeSchema,
+	NodeFromSchema,
+	NodeKind,
+	TreeNodeSchemaClass,
+	TreeNodeSchemaNonClass,
+	TreeNodeSchemaCore,
+	ImplicitFieldSchema,
+	TreeFieldFromImplicitField,
+	ImplicitAllowedTypes,
+	TreeNodeFromImplicitAllowedTypes,
+	InsertableTreeNodeFromImplicitAllowedTypes,
+	TreeMapNode,
+	TreeLeafValue,
+} from "./schemaTypes";
+export { SchemaFactory } from "./schemaFactory";
+export { nodeApi as Tree, TreeApi, TreeNodeEvents } from "./treeApi";
+export { toFlexConfig } from "./toFlexSchema";
+export { SchemaFactoryRecursive } from "./schemaFactoryRecursive";
+
+export {
+	adaptEnum,
+	enumFromStrings,
+	singletonSchema,
+	typedObjectValues,
+} from "./schemaCreationUtilities";
+
+// Below here are things that are used by the above, but not part of the desired API surface.
+import * as InternalClassTreeTypes from "./internal";
+export { InternalClassTreeTypes };
+
+// Exporting the schema (RecursiveObject) to test that recursive types are working correctly.
+// These are `@internal` so they can't be included in the `InternalClassTreeTypes` due to https://github.com/microsoft/rushstack/issues/3639
+export {
+	RecursiveObject as test_RecursiveObject,
+	base as test_RecursiveObject_base,
+} from "./testRecursiveDomain";

package/src/class-tree/integerIndexable.ts

@@ -0,0 +1,120 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/core-utils";
+
+// Note:
+// Currently this file is unused, though it could serve as the implementation of indexing for Lists when class and simple trees are merged.
+
+/**
+ * Info integerIndexable needs to work.
+ */
+export interface IndexLookup<T> {
+	read(index: number): T;
+	write(index: number, value: T): boolean;
+	readonly length: number;
+}
+
+/**
+ * Class which can be indexed with integers from 0 to length -1 like arrays.
+ * Unlike with arrays, this class asserts for out of bounds indexing on both read and write.
+ *
+ * @privateRemarks
+ * This class works by returning a proxy from its constructor which
+ * causes the derived class to get the proxy as its "this" object.
+ */
+export abstract class IntegerIndexable<in out T> {
+	[x: number]: T;
+
+	protected abstract read(index: number): T;
+	protected abstract write(index: number, value: T): boolean;
+
+	public constructor(public length: number) {
+		return integerIndexable(this, this as unknown as IndexLookup<T>);
+	}
+}
+
+export function integerIndexable<T, TTarget extends object>(
+	outerTarget: TTarget,
+	provider: IndexLookup<T>,
+): {
+	[x: number]: T;
+} & TTarget {
+	function isValidIndex(index: number): boolean {
+		return index >= 0 && index < provider.length;
+	}
+
+	function keyToNumber(key: string | symbol): number | undefined {
+		if (typeof key !== "string") {
+			return undefined;
+		}
+		const index = Number.parseInt(key, 10);
+		return Number.isNaN(index) ? undefined : index;
+	}
+
+	const proxyHandler: ProxyHandler<TTarget> = {
+		get: (target, key, receiver): T | unknown => {
+			const index = keyToNumber(key);
+			if (index !== undefined) {
+				assert(isValidIndex(index), 0x839 /* invalid index */);
+				return provider.read(index);
+			}
+
+			// Pass the proxy as the receiver here, so that any methods on the prototype receive `proxy` as `this`.
+			return Reflect.get(target, key, receiver);
+		},
+		getOwnPropertyDescriptor: (target, key): PropertyDescriptor | undefined => {
+			const index = keyToNumber(key);
+			if (index !== undefined) {
+				if (isValidIndex(index)) {
+					const descriptor: PropertyDescriptor = {
+						get() {
+							return provider.read(index);
+						},
+						set(value: T): void {
+							provider.write(index, value);
+						},
+						writable: true,
+						enumerable: true,
+						configurable: true, // Must be 'configurable' if property is absent from proxy target.
+					};
+					return descriptor;
+				} else {
+					return undefined;
+				}
+			}
+
+			return Reflect.getOwnPropertyDescriptor(target, key);
+		},
+		has: (target, key) => {
+			if (typeof key === "string") {
+				const numericKey = Number.parseInt(key, 10);
+				if (!Number.isNaN(numericKey)) {
+					return isValidIndex(numericKey);
+				}
+			}
+			return Reflect.has(target, key);
+		},
+		set: (target, key, newValue): boolean => {
+			const index = keyToNumber(key);
+			if (index !== undefined) {
+				assert(isValidIndex(index), 0x83a /* invalid index */);
+				return provider.write(index, newValue);
+			}
+			return Reflect.set(target, key, newValue);
+		},
+		ownKeys: (target) => {
+			const keys = Reflect.ownKeys(target);
+			for (let index = 0; index < provider.length; index++) {
+				keys.push(index.toString());
+			}
+			return keys;
+		},
+	};
+	const proxy = new Proxy(outerTarget, proxyHandler);
+	return proxy as unknown as {
+		[x: number]: T;
+	} & TTarget;
+}

package/src/class-tree/internal.ts

@@ -0,0 +1,20 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+// Used by public types, but not part of the desired API surface
+
+export {
+	ObjectFromSchemaRecord,
+	InsertableObjectFromSchemaRecord,
+	TreeNodeFromImplicitAllowedTypes,
+	ImplicitAllowedTypes,
+	FieldKind,
+	InsertableTreeFieldFromImplicitField,
+	AllowedTypes,
+	FieldSchema,
+	ApplyKind,
+	InsertableTypedNode,
+	NodeBuilderData,
+} from "./schemaTypes";

package/src/class-tree/schemaCreationUtilities.ts

@@ -0,0 +1,178 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { UsageError } from "@fluidframework/telemetry-utils";
+import { fail } from "../util";
+import { EmptyObject } from "../feature-libraries";
+import { SchemaFactory } from "./schemaFactory";
+// This type is referred to by the base type generated by schema.
+// Adding the import of it here prevents TypeScript from generating inline includes for it in the d.ts file.
+// If we let TypeScript generate these includes, they use relative paths which break API extractor's rollup.
+// eslint-disable-next-line unused-imports/no-unused-imports
+import { NodeFromSchema, type NodeKind as _dummy } from "./schemaTypes";
+
+/**
+ * Create a schema for a node with no state.
+ * @remarks
+ * This is commonly used in unions when the only information needed is which kind of node the value is.
+ * Enums are a common example of this pattern.
+ * @internal
+ */
+export function singletonSchema<TScope extends string, TName extends string | number>(
+	factory: SchemaFactory<TScope, TName>,
+	name: TName,
+) {
+	return class SingletonSchema extends factory.object(name, {}) {
+		public constructor(data?: EmptyObject) {
+			super(data ?? {});
+		}
+		public get value(): TName {
+			return name;
+		}
+	};
+}
+
+/**
+ * Converts an enum into a collection of schema which can be used in a union.
+ * @remarks
+ * Currently only supports `string` enums.
+ * @example
+ * ```typescript
+ * enum Mode {
+ * 	a = "A",
+ * 	b = "B",
+ * }
+ * const ModeNodes = adaptEnum(schema, Mode);
+ * type ModeNodes = NodeFromSchema<(typeof ModeNodes)[keyof typeof ModeNodes]>;
+ * const nodeFromString: ModeNodes = ModeNodes(Mode.a);
+ * const nodeFromSchema: ModeNodes = new ModeNodes.a();
+ * const nameFromNode: Mode = nodeFromSchema.value;
+ * class Parent extends schemaFactory.object("Parent", {
+ * 	mode: typedObjectValues(ModeNodes),
+ * }) {}
+ * ```
+ * @privateRemarks
+ * TODO:
+ * Extends this to support numeric enums.
+ * Maybe require an explicit nested scope to group them under, or at least a warning about collisions.
+ * Maybe just provide `SchemaFactory.nested` to east creating nested scopes?
+ * @internal
+ */
+export function adaptEnum<TScope extends string, const TEnum extends Record<string, string>>(
+	factory: SchemaFactory<TScope>,
+	members: TEnum,
+) {
+	type Values = TEnum[keyof TEnum];
+	const values = Object.values(members) as Values[];
+	const inverse = new Map(Object.entries(members).map(([key, value]) => [value, key])) as Map<
+		Values,
+		keyof TEnum
+	>;
+
+	if (inverse.size !== values.length) {
+		throw new UsageError("All members of enums must have distinct values.");
+	}
+
+	type TOut = {
+		readonly [Property in keyof TEnum]: ReturnType<
+			typeof singletonSchema<TScope, TEnum[Property]>
+		>;
+	};
+	const factoryOut = <TValue extends Values>(value: TValue) => {
+		return new out[inverse.get(value) ?? fail("missing enum value")]({}) as NodeFromSchema<
+			ReturnType<typeof singletonSchema<TScope, TValue>>
+		>;
+	};
+	const out = factoryOut as typeof factoryOut & TOut;
+	for (const [key, value] of Object.entries(members)) {
+		Object.defineProperty(out, key, {
+			enumerable: true,
+			configurable: false,
+			writable: false,
+			value: singletonSchema(factory, value),
+		});
+	}
+
+	return out;
+}
+
+/**
+ * `Object.values`, but with more specific types.
+ * @internal
+ */
+export function typedObjectValues<TKey extends string, TValues>(
+	object: Record<TKey, TValues>,
+): TValues[] {
+	return Object.values(object);
+}
+
+/**
+ * Converts an array of distinct strings into a collection of schema which can be used like an enum style union.
+ * @remarks
+ * The returned collection is also a function which can be used to convert strings into {@link Unhydrated} nodes in the union.
+ * Each node type has a `.value` getter which returns the associated string.
+ *
+ * The produced nodes use the provided strings as their `name`, and don't store any data beyond that.
+ * @example
+ * ```typescript
+ * const Mode = enumFromStrings(schemaFactory, ["Fun", "Cool"]);
+ * type Mode = NodeFromSchema<(typeof Mode)[keyof typeof Mode]>;
+ * const nodeFromString: Mode = Mode("Fun");
+ * const nodeFromSchema: Mode = new Mode.Fun();
+ * const nameFromNode = nodeFromSchema.value;
+ *
+ * class Parent extends schemaFactory.object("Parent", { mode: typedObjectValues(Mode) }) {}
+ * ```
+ * @internal
+ */
+export function enumFromStrings<TScope extends string, const Members extends string>(
+	factory: SchemaFactory<TScope>,
+	members: Members[],
+) {
+	const names = new Set(members);
+	if (names.size !== members.length) {
+		throw new UsageError("All members of enums must have distinct names");
+	}
+
+	type TOut = Record<Members, ReturnType<typeof singletonSchema<TScope, Members>>>;
+	const factoryOut = <TValue extends Members>(value: TValue) => {
+		return new out[value]({}) as NodeFromSchema<
+			ReturnType<typeof singletonSchema<TScope, TValue>>
+		>;
+	};
+	const out = factoryOut as typeof factoryOut & TOut;
+	for (const name of members) {
+		Object.defineProperty(out, name, {
+			enumerable: true,
+			configurable: false,
+			writable: false,
+			value: singletonSchema(factory, name),
+		});
+	}
+
+	return out;
+}
+
+// TODO: Why does this one generate an invalid d.ts file if exported?
+// Tracked by https://github.com/microsoft/TypeScript/issues/56718
+// TODO: replace enumFromStrings above with this simpler implementation when the TypeScript bug is resolved.
+function _enumFromStrings2<TScope extends string, const Members extends readonly string[]>(
+	factory: SchemaFactory<TScope>,
+	members: Members,
+) {
+	const enumObject: {
+		[key in keyof Members as Members[key] extends string ? Members[key] : string]: Members[key];
+	} = Object.create(null);
+	for (const name of members) {
+		Object.defineProperty(enumObject, name, {
+			enumerable: true,
+			configurable: false,
+			writable: false,
+			value: name,
+		});
+	}
+
+	return adaptEnum(factory, enumObject);
+}