@fluidframework/tree 2.90.0-378676 → 2.91.0

package/lib/util/typeCheck.js.map

@@ -1 +1 @@
-{"version":3,"file":"typeCheck.js","sourceRoot":"","sources":["../../src/util/typeCheck.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n// Normally we would put tests in the test directory.\n// However in this case,\n// it's important that the tests are run with the same compiler settings this library is being used with,\n// since this library does not work for some configurations (ex: with strictNullChecks disabled).\n// Since the tests don't generate any JS: they only produce types,\n// importing them here gets us the validation of the compiler settings we want, with no JS size overhead.\nexport type { EnforceTypeCheckTests } from \"./typeCheckTests.js\";\n\n/**\n * Utilities for manipulating the typescript typechecker.\n *\n * @remarks\n * While it appears the the variance parts of this library are made obsolete by TypeScript 4.7's explicit variance annotations,\n * many cases still type check with incorrect variance even when using the explicit annotations,\n * and are fixed by using the patterns in this library.\n *\n * TypeScript uses structural typing if there are no private or protected members,\n * and variance of generic type parameters depends on their usages.\n * Thus when trying to constrain code by adding extra type information,\n * it often fails to actually constrain as desired, and these utilities can help with those cases.\n *\n * This library is designed so that the desired variance can be documented in a way that is easy to read, concise,\n * and allows easy navigation to documentation explaining what is being done\n * for readers who are not familiar with this library.\n * Additionally it constrains the types so the undesired usage patterns will not compile,\n * and will give somewhat intelligible errors.\n *\n * Additionally this library provides the tools needed to test that the type constraints are working as expected,\n * or test any other similar typing constraints in an application.\n *\n * This library assumes you are compiling with --strictFunctionTypes:\n * (Covariance and Contravariance is explained along with how these helpers cause it in typescript at this link)\n * {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-6.html#strict-function-types}.\n * If compiled with a TypeScript configuration that is not strict enough for these features to work,\n * the test suite should fail to build.\n *\n * Classes in TypeScript by default allow all assignments:\n * its only though adding members that any type constraints actually get applied.\n * This library provides types that can be used on a protected member of a class to add the desired constraints.\n *\n * Typical usages (use one field like this at the top of a class):\n * ```typescript\n * protected _typeCheck!: MakeNominal;\n * protected _typeCheck?: Contravariant<T>;\n * protected _typeCheck?: Covariant<T>;\n * protected _typeCheck?: Invariant<T>;\n * protected _typeCheck?: Contravariant<T> & Invariant<K>;\n * ```\n *\n * See tests for examples.\n *\n * Note that all of these cause nominal typing.\n * If constraints on generic type parameter variance are desired, but nominal typing is not,\n * these types can be used on a public field. This case also works with interfaces.\n *\n * Be aware that other members of your type might apply further constraints\n * (ex: you might try and write a Contravariant<T> class, but it ends up being Invariant<T> due to a field of type T).\n *\n * Be aware of TypeScript Bug:\n * {@link https://github.com/microsoft/TypeScript/issues/36906}.\n * This bug is why the fields here are protected not private.\n * Note that this bug is closed as a duplicate of {@link https://github.com/microsoft/TypeScript/issues/20979}\n * which was closed because fixing it would be too large of a breaking change.\n * Thus we expect this bug to be part of TypeScript for the forseeable future.\n */\n\n/**\n * Use this as the type of a protected field to cause a type to use nominal typing instead of structural.\n *\n * @remarks\n * Using nominal typing in this way prevents assignment of objects which are not instances of this class to values of this class's type.\n * Classes which are used with \"instanceof\", or are supposed to be instantiated in particular ways (not just made with object literals)\n * can use this to prevent undesired assignments.\n * @example\n * ```typescript\n * protected _typeCheck!: MakeNominal;\n * ```\n * @privateRemarks\n * See: {@link https://dev.azure.com/intentional/intent/_wiki/wikis/NP%20Platform/7146/Nominal-vs-Structural-Types}\n * @sealed @public\n */\nexport interface MakeNominal {}\n\n/**\n * Constrain generic type parameters to Contravariant.\n *\n * @example\n *\n * ```typescript\n * protected _typeCheck?: Contravariant<T>;\n * ```\n */\nexport interface Contravariant<in T> {\n\t_removeCovariance?: (_: T) => void;\n}\n\n/**\n * Constrain generic type parameters to Covariant.\n *\n * @example\n *\n * ```typescript\n * protected _typeCheck?: Covariant<T>;\n * ```\n */\nexport interface Covariant<out T> {\n\t_removeContravariance?: T;\n}\n\n/**\n * Constrain generic type parameters to Invariant.\n *\n * @example\n *\n * ```typescript\n * protected _typeCheck?: Invariant<T>;\n * ```\n */\nexport interface Invariant<in out T> extends Contravariant<T>, Covariant<T> {}\n\n/**\n * Compile time assert that X is True.\n * To use, simply define a type:\n * `type _check = requireTrue<your type check>;`\n * @internal\n */\nexport type requireTrue<_X extends true> = true;\n\n/**\n * Compile time assert that X is False.\n * To use, simply define a type:\n * `type _check = requireFalse<your type check>;`\n * @internal\n */\nexport type requireFalse<_X extends false> = true;\n\n/**\n * Returns a type parameter that is true iff Source is assignable to Destination.\n *\n * @privateRemarks\n * Use of [] in the extends clause prevents unions from being distributed over this conditional and returning `boolean` in some cases.\n * @see {@link https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types | distributive-conditional-types} for details.\n * @internal\n */\nexport type isAssignableTo<Source, Destination> = [Source] extends [Destination]\n\t? true\n\t: false;\n\n/**\n * Returns a type parameter that is true iff Subset is a strict subset of Superset.\n */\nexport type isStrictSubset<Subset, Superset> =\n\tisAssignableTo<Subset, Superset> extends false\n\t\t? false\n\t\t: isAssignableTo<Superset, Subset> extends true\n\t\t\t? false\n\t\t\t: true;\n\n/**\n * Returns a type parameter that is true iff A and B are assignable to each other, and neither is any.\n * This is useful for checking if the output of a type meta-function is the expected type.\n * @internal\n */\nexport type areSafelyAssignable<A, B> =\n\teitherIsAny<A, B> extends true\n\t\t? false\n\t\t: isAssignableTo<A, B> extends true\n\t\t\t? isAssignableTo<B, A>\n\t\t\t: false;\n\n/**\n * Returns a type parameter that is true iff A is any or B is any.\n * @internal\n */\nexport type eitherIsAny<A, B> = true extends isAny<A> | isAny<B> ? true : false;\n\n/**\n * Returns a type parameter that is true iff T is any.\n *\n * @privateRemarks\n * Only `never` is assignable to `never` (`any` isn't),\n * but `any` distributes over the `extends` here while nothing else should.\n * This can be used to detect `any`.\n * @internal\n */\nexport type isAny<T> = boolean extends (T extends never ? true : false) ? true : false;\n\n/**\n * Compile time assert that A is assignable to (extends) B.\n * To use, simply define a type:\n * `type _check = requireAssignableTo<T, Expected>;`\n * @internal\n */\nexport type requireAssignableTo<_A extends B, B> = true;\n\n/**\n * Returns a type parameter that is true iff the `Keys` union includes all the keys of `T`.\n *\n * @remarks\n * This does not handle when the T has an index signature permitting keys like `string` which\n * TypeScript cannot omit members from.\n *\n * @example\n * ```ts\n * type _check = requireTrue<areOnlyKeys<{a: number, b: number}, 'a' | 'b'>> // true`\n * type _check = requireTrue<areOnlyKeys<{a: number, b: number}, 'a'>> // false`\n * ```\n */\nexport type areOnlyKeys<T, Keys extends keyof T> = isAssignableTo<\n\tRecord<string, never>,\n\tOmit<Required<T>, Keys>\n>;\n"]}
+{"version":3,"file":"typeCheck.js","sourceRoot":"","sources":["../../src/util/typeCheck.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n// Normally we would put tests in the test directory.\n// However in this case,\n// it's important that the tests are run with the same compiler settings this library is being used with,\n// since this library does not work for some configurations (ex: with strictNullChecks disabled).\n// Since the tests don't generate any JS: they only produce types,\n// importing them here gets us the validation of the compiler settings we want, with no JS size overhead.\nexport type { EnforceTypeCheckTests } from \"./typeCheckTests.js\";\n\n/**\n * Utilities for manipulating the typescript typechecker.\n *\n * @remarks\n * While it appears the the variance parts of this library are made obsolete by TypeScript 4.7's explicit variance annotations,\n * many cases still type check with incorrect variance even when using the explicit annotations,\n * and are fixed by using the patterns in this library.\n *\n * TypeScript uses structural typing if there are no private or protected members,\n * and variance of generic type parameters depends on their usages.\n * Thus when trying to constrain code by adding extra type information,\n * it often fails to actually constrain as desired, and these utilities can help with those cases.\n *\n * This library is designed so that the desired variance can be documented in a way that is easy to read, concise,\n * and allows easy navigation to documentation explaining what is being done\n * for readers who are not familiar with this library.\n * Additionally it constrains the types so the undesired usage patterns will not compile,\n * and will give somewhat intelligible errors.\n *\n * Additionally this library provides the tools needed to test that the type constraints are working as expected,\n * or test any other similar typing constraints in an application.\n *\n * This library assumes you are compiling with --strictFunctionTypes:\n * (Covariance and Contravariance is explained along with how these helpers cause it in typescript at this link)\n * {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-6.html#strict-function-types}.\n * If compiled with a TypeScript configuration that is not strict enough for these features to work,\n * the test suite should fail to build.\n *\n * Classes in TypeScript by default allow all assignments:\n * its only though adding members that any type constraints actually get applied.\n * This library provides types that can be used on a protected member of a class to add the desired constraints.\n *\n * Typical usages (use one field like this at the top of a class):\n * ```typescript\n * protected _typeCheck!: MakeNominal;\n * protected _typeCheck?: Contravariant<T>;\n * protected _typeCheck?: Covariant<T>;\n * protected _typeCheck?: Invariant<T>;\n * protected _typeCheck?: Contravariant<T> & Invariant<K>;\n * ```\n *\n * See tests for examples.\n *\n * Note that all of these cause nominal typing.\n * If constraints on generic type parameter variance are desired, but nominal typing is not,\n * these types can be used on a public field. This case also works with interfaces.\n *\n * Be aware that other members of your type might apply further constraints\n * (ex: you might try and write a Contravariant<T> class, but it ends up being Invariant<T> due to a field of type T).\n *\n * Be aware of TypeScript Bug:\n * {@link https://github.com/microsoft/TypeScript/issues/36906}.\n * This bug is why the fields here are protected not private.\n * Note that this bug is closed as a duplicate of {@link https://github.com/microsoft/TypeScript/issues/20979}\n * which was closed because fixing it would be too large of a breaking change.\n * Thus we expect this bug to be part of TypeScript for the forseeable future.\n */\n\n/**\n * Use this as the type of a protected field to cause a type to use nominal typing instead of structural.\n *\n * @remarks\n * Using nominal typing in this way prevents assignment of objects which are not instances of this class to values of this class's type.\n * Classes which are used with \"instanceof\", or are supposed to be instantiated in particular ways (not just made with object literals)\n * can use this to prevent undesired assignments.\n * @example\n * ```typescript\n * protected _typeCheck!: MakeNominal;\n * ```\n * @privateRemarks\n * See: {@link https://dev.azure.com/intentional/intent/_wiki/wikis/NP%20Platform/7146/Nominal-vs-Structural-Types}\n * @sealed @public\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type -- Intentionally empty; used as a nominal type brand.\nexport interface MakeNominal {}\n\n/**\n * Constrain generic type parameters to Contravariant.\n *\n * @example\n *\n * ```typescript\n * protected _typeCheck?: Contravariant<T>;\n * ```\n */\nexport interface Contravariant<in T> {\n\t_removeCovariance?: (_: T) => void;\n}\n\n/**\n * Constrain generic type parameters to Covariant.\n *\n * @example\n *\n * ```typescript\n * protected _typeCheck?: Covariant<T>;\n * ```\n */\nexport interface Covariant<out T> {\n\t_removeContravariance?: T;\n}\n\n/**\n * Constrain generic type parameters to Invariant.\n *\n * @example\n *\n * ```typescript\n * protected _typeCheck?: Invariant<T>;\n * ```\n */\nexport interface Invariant<in out T> extends Contravariant<T>, Covariant<T> {}\n\n/**\n * Compile time assert that X is True.\n * To use, simply define a type:\n * `type _check = requireTrue<your type check>;`\n * @internal\n */\nexport type requireTrue<_X extends true> = true;\n\n/**\n * Compile time assert that X is False.\n * To use, simply define a type:\n * `type _check = requireFalse<your type check>;`\n * @internal\n */\nexport type requireFalse<_X extends false> = true;\n\n/**\n * Returns a type parameter that is true iff Source is assignable to Destination.\n *\n * @privateRemarks\n * Use of [] in the extends clause prevents unions from being distributed over this conditional and returning `boolean` in some cases.\n * @see {@link https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types | distributive-conditional-types} for details.\n * @internal\n */\nexport type isAssignableTo<Source, Destination> = [Source] extends [Destination]\n\t? true\n\t: false;\n\n/**\n * Returns a type parameter that is true iff Subset is a strict subset of Superset.\n */\nexport type isStrictSubset<Subset, Superset> =\n\tisAssignableTo<Subset, Superset> extends false\n\t\t? false\n\t\t: isAssignableTo<Superset, Subset> extends true\n\t\t\t? false\n\t\t\t: true;\n\n/**\n * Returns a type parameter that is true iff A and B are assignable to each other, and neither is any.\n * This is useful for checking if the output of a type meta-function is the expected type.\n * @internal\n */\nexport type areSafelyAssignable<A, B> =\n\teitherIsAny<A, B> extends true\n\t\t? false\n\t\t: isAssignableTo<A, B> extends true\n\t\t\t? isAssignableTo<B, A>\n\t\t\t: false;\n\n/**\n * Returns a type parameter that is true iff A is any or B is any.\n * @internal\n */\nexport type eitherIsAny<A, B> = true extends isAny<A> | isAny<B> ? true : false;\n\n/**\n * Returns a type parameter that is true iff T is any.\n *\n * @privateRemarks\n * Only `never` is assignable to `never` (`any` isn't),\n * but `any` distributes over the `extends` here while nothing else should.\n * This can be used to detect `any`.\n * @internal\n */\nexport type isAny<T> = boolean extends (T extends never ? true : false) ? true : false;\n\n/**\n * Compile time assert that A is assignable to (extends) B.\n * To use, simply define a type:\n * `type _check = requireAssignableTo<T, Expected>;`\n * @internal\n */\nexport type requireAssignableTo<_A extends B, B> = true;\n\n/**\n * Returns a type parameter that is true iff the `Keys` union includes all the keys of `T`.\n *\n * @remarks\n * This does not handle when the T has an index signature permitting keys like `string` which\n * TypeScript cannot omit members from.\n *\n * @example\n * ```ts\n * type _check = requireTrue<areOnlyKeys<{a: number, b: number}, 'a' | 'b'>> // true`\n * type _check = requireTrue<areOnlyKeys<{a: number, b: number}, 'a'>> // false`\n * ```\n */\nexport type areOnlyKeys<T, Keys extends keyof T> = isAssignableTo<\n\tRecord<string, never>,\n\tOmit<Required<T>, Keys>\n>;\n"]}

package/lib/util/typeUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typeUtils.d.ts","sourceRoot":"","sources":["../../src/util/typeUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AAEH;;;;GAIG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC;KAAG,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC;CAAE,CAAC,CAAC,YAAY,CAAC,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,MAAM,eAAe,GAAG,KAAK,CAAC;AA8BpC;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,yBAAyB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,CAAC,IAAI;IACrE,QAAQ,EAAE,CAAC,IAAI,MAAM,GAAG,MAAM,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK;CACxD,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAAI;IACxC,QAAQ,EAAE,CAAC,IAAI,MAAM,GAAG,CAAC;CACzB,GAAG;IACH,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,KAAK;CAC9B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,IAAI,CAAC,SAAS,OAAO,GAC/C,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,GACf,KAAK,GACL,IAAI,GACL,OAAO,CAAC;AAEX;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,KAAK,CAAC,SAAS,CACtF,CAAC,EAAE,MAAM,CAAC,KACN,OAAO,GACT,CAAC,GACD,KAAK,CAAC;AAET;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,CACnB,KAAK,EACL,oBAAoB,GAAG,mBAAmB,CACzC,KAAK,SAAS,OAAO,GAAG,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,GAAG,KAAK,CAClD,IACE,oBAAoB,SAAS,CAAC,CAAC,EAAE,MAAM,KAAK,KAAK,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;AAE1E;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,YAAY,CACvB,KAAK,EACL,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,EACxB,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,IACpB,OAAO,CAAC,KAAK,CAAC,SAAS,IAAI,GAC5B,YAAY,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,GAClD,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,YAAY,CAAC,CAAC,CAAC,CAEjE"}
+{"version":3,"file":"typeUtils.d.ts","sourceRoot":"","sources":["../../src/util/typeUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AAEH;;;;GAIG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC;KAAG,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC;CAAE,CAAC,CAAC,YAAY,CAAC,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,MAAM,eAAe,GAAG,KAAK,CAAC;AA8BpC;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,yBAAyB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,CAAC,IAAI;IACrE,QAAQ,EAAE,CAAC,IAAI,MAAM,GAAG,MAAM,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK;CACxD,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAAI;IACxC,QAAQ,EAAE,CAAC,IAAI,MAAM,GAAG,CAAC;CACzB,GAAG;IACH,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,KAAK;CAC9B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,IAAI,CAAC,SAAS,OAAO,GAC/C,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,GACf,KAAK,GACL,IAAI,GACL,OAAO,CAAC;AAEX;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,KAAK,CAAC,SAAS,CACtF,CAAC,EAAE,MAAM,CAAC,KACN,OAAO,GACT,CAAC,GACD,KAAK,CAAC;AAET;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,CACnB,KAAK,EACL,oBAAoB,GAAG,mBAAmB,CACzC,KAAK,SAAS,OAAO,GAAG,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,GAAG,KAAK,CAClD,IACE,oBAAoB,SAAS,CAAC,CAAC,EAAE,MAAM,KAAK,KAAK,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;AAE1E;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,YAAY,CAAC,KAAK,EAAE,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,EAAE,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,IAChF,OAAO,CAAC,KAAK,CAAC,SAAS,IAAI,GACxB,YAAY,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,GAClD,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,YAAY,CAAC,CAAC,CAAC,CAEjE"}

package/lib/util/typeUtils.js.map

@@ -1 +1 @@
-{"version":3,"file":"typeUtils.js","sourceRoot":"","sources":["../../src/util/typeUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA8EH,wIAAwI;AACxI,CAAC;IAwBA,qDAAqD;AACtD,CAAC;AA8FD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,kBAAkB,CAAI,KAAU;IAC/C,OAAO,KAAwB,CAAC;AACjC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Utilities for manipulating types.\n */\n\n/**\n * Return a type thats equivalent to the input, but with different IntelliSense.\n * This tends to convert unions and intersections into objects.\n * @system @public\n */\nexport type FlattenKeys<T> = [{ [Property in keyof T]: T[Property] }][_InlineTrick];\n\n/**\n * Use for trick to \"inline\" generic types.\n *\n * @remarks\n * The TypeScript compiler can be convinced to inline a generic type\n * (so the result of evaluating the generic type show up in IntelliSense and error messages instead of just the invocation of the generic type)\n * by creating an object with a field, and returning the type of that field.\n *\n * For example:\n * ```typescript\n * type MyGeneric<T1, T2> = {x: T1 extends [] ? T1 : T2 };\n * type MyGenericExpanded<T1, T2> = [{x: T1 extends [] ? T1 : T2 }][_InlineTrick]\n *\n * // Type is MyGeneric<5, string>\n * const foo: MyGeneric<5, string> = {x: \"x\"}\n * // Type is {x: \"x\"}\n * const foo2: MyGenericExpanded<5, string> = {x: \"x\"}\n * ```\n *\n * This constant is defined to provide a way to find this documentation from types which use this pattern,\n * and to locate types which use this pattern in case they need updating for compiler changes.\n * @system @public\n */\nexport type _InlineTrick = 0;\n\n/**\n * Use for trick to prevent self reference error `ts(2456)`.\n *\n * Prefix a type expression with `K extends _RecursiveTrick ? _RecursiveTrick : ` for some K to break the cycle.\n *\n * @remarks\n * The TypeScript compiler handles some cases of recursive types, but not others.\n * Sometimes adding an otherwise needless conditional can make a type compile.\n * Use this type in such cases.\n *\n *For example:\n * ```typescript\n * // The TypeScript compiler can't handle this case\n * type Broken<T> = FlattenKeys<\n *\t{\n * \t\t[K in keyof T]: 0;\n * \t} & {\n * \t\t[K in keyof T]: Broken<T[K]>;\n * \t}\n * >;\n *\n * // Adding `K extends _RecursiveTrick ? _RecursiveTrick :` makes it compile, and has no effect on the type produced.\n * type Works<T> = FlattenKeys<\n * \t{\n * \t\t[K in keyof T]: 0;\n * \t} & {\n * \t\t// Trick added here. Since `k` never extends `never`, the second conditional option is always taken,\n * \t\t// making this equivalent to the broken version, except this one compiles.\n * \t\t[K in keyof T]: K extends _RecursiveTrick ? _RecursiveTrick : Works<T[K]>;\n * \t}\n * >;\n * ```\n *\n * This trick appears to start working in TypeScript 4.1 and is confirmed to still work in 5.0.4.\n *\n * This constant is defined to provide a way to find this documentation from types which use this pattern,\n * and to locate types which use this pattern in case they need updating for compiler changes.\n */\nexport type _RecursiveTrick = never;\n\n// This block is kept here to ensure the above example behaves as documented, and can be copied into the example to update it as needed.\n{\n\t/* eslint-disable @typescript-eslint/no-unused-vars */\n\n\t// @ts-expect-error The TypeScript compiler can't handle this case\n\ttype Broken<T> = FlattenKeys<\n\t\t{\n\t\t\t[K in keyof T]: 0;\n\t\t} & {\n\t\t\t// @ts-expect-error Same error as above.\n\t\t\t[K in keyof T]: Broken<T[K]>;\n\t\t}\n\t>;\n\n\t// Adding `K extends _RecursiveTrick ? _RecursiveTrick:` OR `T extends _RecursiveTrick ? _RecursiveTrick :` makes it compile and has no effect on the type produced.\n\ttype Works<T> = FlattenKeys<\n\t\t{\n\t\t\t[K in keyof T]: 0;\n\t\t} & {\n\t\t\t// Trick added here. Since `K` never extends `never`, the second conditional option is always taken,\n\t\t\t// making this equivalent to the broken version, except this one compiles.\n\t\t\t[K in keyof T]: T extends _RecursiveTrick ? _RecursiveTrick : Works<T[K]>;\n\t\t}\n\t>;\n\n\t/* eslint-enable @typescript-eslint/no-unused-vars */\n}\n\n/**\n * Alternative to the built in Record type which does not permit unexpected members,\n * and is readonly.\n *\n * @remarks\n * This does not work correctly when `K` is more specific than `string` or `symbol`.\n * For example `{a: 5}` is not assignable to `RestrictiveReadonlyRecord<\"a\",: number>`\n *\n * @privateRemarks\n * `number` is not allowed as a key here since doing so causes the compiler to reject recursive schema.\n * The cause for this is unclear, but empirically it was the case when this comment was written.\n *\n * @deprecated Use a more robust / specific type instead. This type never worked as intended.\n * @public\n */\nexport type RestrictiveReadonlyRecord<K extends symbol | string, T> = {\n\treadonly [P in symbol | string]: P extends K ? T : never;\n};\n\n/**\n * Alternative to the built-in `Record<string, T>` type which is readonly and does not permit symbols.\n * @remarks\n * It would be nice if `keyof RestrictiveStringRecord<T>` returned string, but it does not: use `keyof RestrictiveStringRecord<T> & string` instead.\n * @system @public\n */\nexport type RestrictiveStringRecord<T> = {\n\treadonly [P in string]: T;\n} & {\n\treadonly [P in symbol]?: never;\n};\n\n/**\n * Returns `true` if T is a union and false if it is not.\n * @typeparam T - Type to test if it is a union.\n * @typeparam T2 - Do not specify: default value used as implementation detail.\n * @system @public\n */\nexport type IsUnion<T, T2 = T> = T extends unknown\n\t? [T2] extends [T]\n\t\t? false\n\t\t: true\n\t: \"error\";\n\n/**\n * Convert a union of types to an intersection of those types. Useful for `TransformEvents`.\n * @privateRemarks\n * First an always true extends clause is used (T extends T) to distribute T into to a union of types contravariant over each member of the T union.\n * Then the constraint on the type parameter in this new context is inferred, giving the intersection.\n * @system @public\n */\nexport type UnionToIntersection<T> = (T extends T ? (k: T) => unknown : never) extends (\n\tk: infer U,\n) => unknown\n\t? U\n\t: never;\n\n/**\n * Gets the first item of a union type.\n *\n * @typeparam Union - The union to convert.\n * @typeparam AsOverloadedFunction - Implementation detail: do not specify.\n * @system @beta\n */\nexport type PopUnion<\n\tUnion,\n\tAsOverloadedFunction = UnionToIntersection<\n\t\tUnion extends unknown ? (f: Union) => void : never\n\t>,\n> = AsOverloadedFunction extends (a: infer First) => void ? First : never;\n\n/**\n * Converts a union type to a tuple type.\n *\n * @typeparam T - The union to convert.\n * @typeparam A - Implementation detail: do not specify.\n * @typeparam First - Implementation detail: do not specify.\n *\n * @privateRemarks\n * `A` is a tuple to prepend members of the union to.\n *\n * https://www.hacklewayne.com/typescript-convert-union-to-tuple-array-yes-but-how and https://catchts.com/union-array both explain the general approach this uses pretty well.\n * This implementation is inspired to those, but slightly different in implementation.\n * @system @beta\n */\nexport type UnionToTuple<\n\tUnion,\n\tA extends unknown[] = [],\n\tFirst = PopUnion<Union>,\n> = IsUnion<Union> extends true\n\t? UnionToTuple<Exclude<Union, First>, [First, ...A]>\n\t: [Union, ...A];\n\n/**\n * This is unsafe, meaning that the returned value might not match its type.\n *\n * For the result to match its type, T must be a union of the types of each item in `items` in the order that they occur.\n * For this to be possible, there must be no duplicate or overlapping types.\n * This is fragile and must be used with care.\n *\n * @remarks\n * The main use-case for this is recovering lost information from {@link AllowedTypes} which is necessary to preserve when using them with {@link Input} APIs.\n * Since {@link AllowedTypes} is actually order independent, it is somewhat safer when used to produce `AllowedTypes`.\n *\n * @example\n * ```typescript\n * // Gives imprecise type (typeof A | typeof B)[]\n * const schemaBad = [A, B];\n * // Fixes the type to be [typeof A, typeof B]\n * const schema = unsafeArrayToTuple(schemaBad);\n *\n * const config = new TreeViewConfiguration({ schema });\n * ```\n * @alpha\n */\nexport function unsafeArrayToTuple<T>(items: T[]): UnionToTuple<T> {\n\treturn items as UnionToTuple<T>;\n}\n"]}
+{"version":3,"file":"typeUtils.js","sourceRoot":"","sources":["../../src/util/typeUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA8EH,wIAAwI;AACxI,CAAC;IAwBA,qDAAqD;AACtD,CAAC;AA2FD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,kBAAkB,CAAI,KAAU;IAC/C,OAAO,KAAwB,CAAC;AACjC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Utilities for manipulating types.\n */\n\n/**\n * Return a type thats equivalent to the input, but with different IntelliSense.\n * This tends to convert unions and intersections into objects.\n * @system @public\n */\nexport type FlattenKeys<T> = [{ [Property in keyof T]: T[Property] }][_InlineTrick];\n\n/**\n * Use for trick to \"inline\" generic types.\n *\n * @remarks\n * The TypeScript compiler can be convinced to inline a generic type\n * (so the result of evaluating the generic type show up in IntelliSense and error messages instead of just the invocation of the generic type)\n * by creating an object with a field, and returning the type of that field.\n *\n * For example:\n * ```typescript\n * type MyGeneric<T1, T2> = {x: T1 extends [] ? T1 : T2 };\n * type MyGenericExpanded<T1, T2> = [{x: T1 extends [] ? T1 : T2 }][_InlineTrick]\n *\n * // Type is MyGeneric<5, string>\n * const foo: MyGeneric<5, string> = {x: \"x\"}\n * // Type is {x: \"x\"}\n * const foo2: MyGenericExpanded<5, string> = {x: \"x\"}\n * ```\n *\n * This constant is defined to provide a way to find this documentation from types which use this pattern,\n * and to locate types which use this pattern in case they need updating for compiler changes.\n * @system @public\n */\nexport type _InlineTrick = 0;\n\n/**\n * Use for trick to prevent self reference error `ts(2456)`.\n *\n * Prefix a type expression with `K extends _RecursiveTrick ? _RecursiveTrick : ` for some K to break the cycle.\n *\n * @remarks\n * The TypeScript compiler handles some cases of recursive types, but not others.\n * Sometimes adding an otherwise needless conditional can make a type compile.\n * Use this type in such cases.\n *\n *For example:\n * ```typescript\n * // The TypeScript compiler can't handle this case\n * type Broken<T> = FlattenKeys<\n *\t{\n * \t\t[K in keyof T]: 0;\n * \t} & {\n * \t\t[K in keyof T]: Broken<T[K]>;\n * \t}\n * >;\n *\n * // Adding `K extends _RecursiveTrick ? _RecursiveTrick :` makes it compile, and has no effect on the type produced.\n * type Works<T> = FlattenKeys<\n * \t{\n * \t\t[K in keyof T]: 0;\n * \t} & {\n * \t\t// Trick added here. Since `k` never extends `never`, the second conditional option is always taken,\n * \t\t// making this equivalent to the broken version, except this one compiles.\n * \t\t[K in keyof T]: K extends _RecursiveTrick ? _RecursiveTrick : Works<T[K]>;\n * \t}\n * >;\n * ```\n *\n * This trick appears to start working in TypeScript 4.1 and is confirmed to still work in 5.0.4.\n *\n * This constant is defined to provide a way to find this documentation from types which use this pattern,\n * and to locate types which use this pattern in case they need updating for compiler changes.\n */\nexport type _RecursiveTrick = never;\n\n// This block is kept here to ensure the above example behaves as documented, and can be copied into the example to update it as needed.\n{\n\t/* eslint-disable @typescript-eslint/no-unused-vars */\n\n\t// @ts-expect-error The TypeScript compiler can't handle this case\n\ttype Broken<T> = FlattenKeys<\n\t\t{\n\t\t\t[K in keyof T]: 0;\n\t\t} & {\n\t\t\t// @ts-expect-error Same error as above.\n\t\t\t[K in keyof T]: Broken<T[K]>;\n\t\t}\n\t>;\n\n\t// Adding `K extends _RecursiveTrick ? _RecursiveTrick:` OR `T extends _RecursiveTrick ? _RecursiveTrick :` makes it compile and has no effect on the type produced.\n\ttype Works<T> = FlattenKeys<\n\t\t{\n\t\t\t[K in keyof T]: 0;\n\t\t} & {\n\t\t\t// Trick added here. Since `K` never extends `never`, the second conditional option is always taken,\n\t\t\t// making this equivalent to the broken version, except this one compiles.\n\t\t\t[K in keyof T]: T extends _RecursiveTrick ? _RecursiveTrick : Works<T[K]>;\n\t\t}\n\t>;\n\n\t/* eslint-enable @typescript-eslint/no-unused-vars */\n}\n\n/**\n * Alternative to the built in Record type which does not permit unexpected members,\n * and is readonly.\n *\n * @remarks\n * This does not work correctly when `K` is more specific than `string` or `symbol`.\n * For example `{a: 5}` is not assignable to `RestrictiveReadonlyRecord<\"a\",: number>`\n *\n * @privateRemarks\n * `number` is not allowed as a key here since doing so causes the compiler to reject recursive schema.\n * The cause for this is unclear, but empirically it was the case when this comment was written.\n *\n * @deprecated Use a more robust / specific type instead. This type never worked as intended.\n * @public\n */\nexport type RestrictiveReadonlyRecord<K extends symbol | string, T> = {\n\treadonly [P in symbol | string]: P extends K ? T : never;\n};\n\n/**\n * Alternative to the built-in `Record<string, T>` type which is readonly and does not permit symbols.\n * @remarks\n * It would be nice if `keyof RestrictiveStringRecord<T>` returned string, but it does not: use `keyof RestrictiveStringRecord<T> & string` instead.\n * @system @public\n */\nexport type RestrictiveStringRecord<T> = {\n\treadonly [P in string]: T;\n} & {\n\treadonly [P in symbol]?: never;\n};\n\n/**\n * Returns `true` if T is a union and false if it is not.\n * @typeparam T - Type to test if it is a union.\n * @typeparam T2 - Do not specify: default value used as implementation detail.\n * @system @public\n */\nexport type IsUnion<T, T2 = T> = T extends unknown\n\t? [T2] extends [T]\n\t\t? false\n\t\t: true\n\t: \"error\";\n\n/**\n * Convert a union of types to an intersection of those types. Useful for `TransformEvents`.\n * @privateRemarks\n * First an always true extends clause is used (T extends T) to distribute T into to a union of types contravariant over each member of the T union.\n * Then the constraint on the type parameter in this new context is inferred, giving the intersection.\n * @system @public\n */\nexport type UnionToIntersection<T> = (T extends T ? (k: T) => unknown : never) extends (\n\tk: infer U,\n) => unknown\n\t? U\n\t: never;\n\n/**\n * Gets the first item of a union type.\n *\n * @typeparam Union - The union to convert.\n * @typeparam AsOverloadedFunction - Implementation detail: do not specify.\n * @system @beta\n */\nexport type PopUnion<\n\tUnion,\n\tAsOverloadedFunction = UnionToIntersection<\n\t\tUnion extends unknown ? (f: Union) => void : never\n\t>,\n> = AsOverloadedFunction extends (a: infer First) => void ? First : never;\n\n/**\n * Converts a union type to a tuple type.\n *\n * @typeparam T - The union to convert.\n * @typeparam A - Implementation detail: do not specify.\n * @typeparam First - Implementation detail: do not specify.\n *\n * @privateRemarks\n * `A` is a tuple to prepend members of the union to.\n *\n * https://www.hacklewayne.com/typescript-convert-union-to-tuple-array-yes-but-how and https://catchts.com/union-array both explain the general approach this uses pretty well.\n * This implementation is inspired to those, but slightly different in implementation.\n * @system @beta\n */\nexport type UnionToTuple<Union, A extends unknown[] = [], First = PopUnion<Union>> =\n\tIsUnion<Union> extends true\n\t\t? UnionToTuple<Exclude<Union, First>, [First, ...A]>\n\t\t: [Union, ...A];\n\n/**\n * This is unsafe, meaning that the returned value might not match its type.\n *\n * For the result to match its type, T must be a union of the types of each item in `items` in the order that they occur.\n * For this to be possible, there must be no duplicate or overlapping types.\n * This is fragile and must be used with care.\n *\n * @remarks\n * The main use-case for this is recovering lost information from {@link AllowedTypes} which is necessary to preserve when using them with {@link Input} APIs.\n * Since {@link AllowedTypes} is actually order independent, it is somewhat safer when used to produce `AllowedTypes`.\n *\n * @example\n * ```typescript\n * // Gives imprecise type (typeof A | typeof B)[]\n * const schemaBad = [A, B];\n * // Fixes the type to be [typeof A, typeof B]\n * const schema = unsafeArrayToTuple(schemaBad);\n *\n * const config = new TreeViewConfiguration({ schema });\n * ```\n * @alpha\n */\nexport function unsafeArrayToTuple<T>(items: T[]): UnionToTuple<T> {\n\treturn items as UnionToTuple<T>;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/tree",
-  "version": "2.90.0-378676",
+  "version": "2.91.0",
   "description": "Distributed tree",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -15,52 +15,52 @@
   "exports": {
     ".": {
       "import": {
-        "types": "./lib/public.d.ts",
-        "default": "./lib/index.js"
+        "types": "./lib/entrypoints/public.d.ts",
+        "default": "./lib/entrypoints/public.js"
       },
       "require": {
-        "types": "./dist/public.d.ts",
-        "default": "./dist/index.js"
+        "types": "./dist/entrypoints/public.d.ts",
+        "default": "./dist/entrypoints/public.js"
       }
     },
     "./alpha": {
       "import": {
-        "types": "./lib/alpha.d.ts",
-        "default": "./lib/index.js"
+        "types": "./lib/entrypoints/alpha.d.ts",
+        "default": "./lib/entrypoints/alpha.js"
       },
       "require": {
-        "types": "./dist/alpha.d.ts",
-        "default": "./dist/index.js"
+        "types": "./dist/entrypoints/alpha.d.ts",
+        "default": "./dist/entrypoints/alpha.js"
       }
     },
     "./beta": {
       "import": {
-        "types": "./lib/beta.d.ts",
-        "default": "./lib/index.js"
+        "types": "./lib/entrypoints/beta.d.ts",
+        "default": "./lib/entrypoints/beta.js"
       },
       "require": {
-        "types": "./dist/beta.d.ts",
-        "default": "./dist/index.js"
+        "types": "./dist/entrypoints/beta.d.ts",
+        "default": "./dist/entrypoints/beta.js"
       }
     },
     "./internal": {
       "import": {
-        "types": "./lib/index.d.ts",
-        "default": "./lib/index.js"
+        "types": "./lib/entrypoints/internal.d.ts",
+        "default": "./lib/entrypoints/internal.js"
       },
       "require": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
+        "types": "./dist/entrypoints/internal.d.ts",
+        "default": "./dist/entrypoints/internal.js"
       }
     },
     "./legacy": {
       "import": {
-        "types": "./lib/legacy.d.ts",
-        "default": "./lib/index.js"
+        "types": "./lib/entrypoints/legacy.d.ts",
+        "default": "./lib/entrypoints/legacy.js"
       },
       "require": {
-        "types": "./dist/legacy.d.ts",
-        "default": "./dist/index.js"
+        "types": "./dist/entrypoints/legacy.d.ts",
+        "default": "./dist/entrypoints/legacy.js"
       }
     },
     "./internal/test": {
@@ -77,7 +77,7 @@
     }
   },
   "main": "lib/index.js",
-  "types": "lib/public.d.ts",
+  "types": "lib/entrypoints/public.d.ts",
   "c8": {
     "all": true,
     "cache-dir": "nyc/.cache",
@@ -101,17 +101,17 @@
     "temp-directory": "nyc/.nyc_output"
   },
   "dependencies": {
-    "@fluid-internal/client-utils": "2.90.0-378676",
-    "@fluidframework/container-runtime": "2.90.0-378676",
-    "@fluidframework/core-interfaces": "2.90.0-378676",
-    "@fluidframework/core-utils": "2.90.0-378676",
-    "@fluidframework/datastore-definitions": "2.90.0-378676",
-    "@fluidframework/driver-definitions": "2.90.0-378676",
-    "@fluidframework/id-compressor": "2.90.0-378676",
-    "@fluidframework/runtime-definitions": "2.90.0-378676",
-    "@fluidframework/runtime-utils": "2.90.0-378676",
-    "@fluidframework/shared-object-base": "2.90.0-378676",
-    "@fluidframework/telemetry-utils": "2.90.0-378676",
+    "@fluid-internal/client-utils": "~2.91.0",
+    "@fluidframework/container-runtime": "~2.91.0",
+    "@fluidframework/core-interfaces": "~2.91.0",
+    "@fluidframework/core-utils": "~2.91.0",
+    "@fluidframework/datastore-definitions": "~2.91.0",
+    "@fluidframework/driver-definitions": "~2.91.0",
+    "@fluidframework/id-compressor": "~2.91.0",
+    "@fluidframework/runtime-definitions": "~2.91.0",
+    "@fluidframework/runtime-utils": "~2.91.0",
+    "@fluidframework/shared-object-base": "~2.91.0",
+    "@fluidframework/telemetry-utils": "~2.91.0",
     "@sinclair/typebox": "^0.34.13",
     "@tylerbu/sorted-btree-es6": "^2.1.1",
     "@types/ungap__structured-clone": "^1.2.0",
@@ -121,21 +121,21 @@
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.2",
-    "@biomejs/biome": "~1.9.3",
-    "@fluid-internal/mocha-test-setup": "2.90.0-378676",
-    "@fluid-private/stochastic-test-utils": "2.90.0-378676",
-    "@fluid-private/test-dds-utils": "2.90.0-378676",
-    "@fluid-private/test-drivers": "2.90.0-378676",
+    "@biomejs/biome": "~2.4.5",
+    "@fluid-internal/mocha-test-setup": "~2.91.0",
+    "@fluid-private/stochastic-test-utils": "~2.91.0",
+    "@fluid-private/test-dds-utils": "~2.91.0",
+    "@fluid-private/test-drivers": "~2.91.0",
     "@fluid-tools/benchmark": "^0.52.0",
     "@fluid-tools/build-cli": "^0.63.0",
     "@fluidframework/build-common": "^2.0.3",
     "@fluidframework/build-tools": "^0.63.0",
-    "@fluidframework/container-definitions": "2.90.0-378676",
-    "@fluidframework/container-loader": "2.90.0-378676",
-    "@fluidframework/eslint-config-fluid": "2.90.0-378676",
-    "@fluidframework/test-runtime-utils": "2.90.0-378676",
-    "@fluidframework/test-utils": "2.90.0-378676",
-    "@fluidframework/tree-previous": "npm:@fluidframework/tree@2.82.0",
+    "@fluidframework/container-definitions": "~2.91.0",
+    "@fluidframework/container-loader": "~2.91.0",
+    "@fluidframework/eslint-config-fluid": "~2.91.0",
+    "@fluidframework/test-runtime-utils": "~2.91.0",
+    "@fluidframework/test-utils": "~2.91.0",
+    "@fluidframework/tree-previous": "npm:@fluidframework/tree@2.83.0",
     "@microsoft/api-extractor": "7.52.11",
     "@types/diff": "^3.5.1",
     "@types/easy-table": "^0.0.32",
@@ -153,9 +153,9 @@
     "eslint": "~9.39.1",
     "eslint-config-prettier": "~10.1.8",
     "jiti": "^2.6.1",
-    "mocha": "^10.8.2",
+    "mocha": "^11.7.5",
     "mocha-multi-reporters": "^1.5.1",
-    "rimraf": "^6.1.2",
+    "rimraf": "^6.1.3",
     "typescript": "~5.4.5"
   },
   "fluidBuild": {
@@ -179,8 +179,6 @@
   },
   "scripts": {
     "api": "fluid-build . --task api",
-    "api-extractor:commonjs": "flub generate entrypoints --outFileLegacyBeta legacy --outDir ./dist",
-    "api-extractor:esnext": "flub generate entrypoints --outFileLegacyBeta legacy --outDir ./lib --node10TypeCompat",
     "bench": "mocha --timeout 999999 --perfMode --parentProcess --fgrep @Benchmark --fgrep @ExecutionTime --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 --fgrep @ExecutionTime --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",
@@ -190,6 +188,7 @@
     "build:commonjs": "fluid-build . --task commonjs",
     "build:compile": "fluid-build . --task compile",
     "build:docs": "api-extractor run --local",
+    "build:entrypoints:node10": "flub generate node10Entrypoints",
     "build:esnext": "tsc --project ./tsconfig.json",
     "build:genver": "gen-version",
     "build:test": "npm run build:test:esm && npm run build:test:cjs",
@@ -212,13 +211,14 @@
     "ci:build:api-reports:current": "api-extractor run --config api-extractor/api-extractor.current.json",
     "ci:build:api-reports:legacy": "api-extractor run --config api-extractor/api-extractor.legacy.json",
     "ci:build:docs": "api-extractor run",
-    "clean": "rimraf --glob dist lib {alpha,beta,internal,legacy}.d.ts \"**/*.tsbuildinfo\" \"**/*.build.log\" _api-extractor-temp nyc",
+    "clean": "rimraf --glob dist lib {alpha,beta,internal}.d.ts \"**/*.tsbuildinfo\" \"**/*.build.log\" _api-extractor-temp nyc",
     "depcruise": "depcruise src/ --ignore-known",
     "depcruise:regen-known-issues": "depcruise-baseline src",
     "eslint": "eslint --quiet --format stylish src",
     "eslint:fix": "eslint --quiet --format stylish src --fix --fix-type problem,suggestion,layout",
     "format": "npm run format:biome",
     "format:biome": "biome check . --write",
+    "generate:entrypoint-sources": "scripts/generate-entrypoint-sources.sh",
     "lint": "fluid-build . --task lint",
     "lint:fix": "fluid-build . --task eslint:fix --task format",
     "pack:tests": "tar -cf ./tree.test-files.tar ./src/test ./dist/test ./lib/test",

package/scripts/generate-entrypoint-sources.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+set -eu -o pipefail
+
+# Generate entrypoint .d.ts files in lib/entrypoints, then transform them into
+# source .ts files under src/entrypoints.
+
+# This script is not inlined into package.json to avoid detection of outputs
+# from fluid-build-tasks-tsc policy check that doesn't understand that the
+# script is not a part of the regular build.
+# This does clobber build output (detected correctly by policy check) and
+# therefore a build should always be run after this script to restore validity
+# of .d.ts files.
+
+# 0. Make sure lib/entrypoints exists (a limitation of "flub generate entrypoints")
+
+mkdir -p ./lib/entrypoints
+
+# 1. Generate entrypoint .d.ts files in lib/entrypoints.
+
+pnpm flub generate entrypoints --outFileLegacyBeta legacy --outDir ./lib/entrypoints
+
+# 2. Copy generated .d.ts files to src/entrypoints as .ts files.
+# A bug in "flub generate entrypoints" requires "./index.js" to be replaced with
+# "../index.js" hence use of sed.
+
+for tag in public beta alpha legacy; do
+	sed "s|\./|../|" "./lib/entrypoints/${tag}.d.ts" > "./src/entrypoints/${tag}.ts"
+done

package/src/codec/codec.ts

@@ -366,6 +366,8 @@ export const unitCodec: IJsonCodec<
 /**
  * Wraps a codec with JSON schema validation for its encoded type.
  * @returns An {@link IJsonCodec} which validates the data it encodes and decodes matches the provided schema.
+ * @remarks
+ * Eventually all codecs should use the same pattern implemented by ClientVersionDispatchingCodecBuilder, resulting in that having the only use of this API.
  */
 export function withSchemaValidation<
 	TInMemoryFormat,
@@ -386,16 +388,15 @@ export function withSchemaValidation<
 		encode: (obj: TInMemoryFormat, context: TContext): TEncodedFormat => {
 			const encoded = codec.encode(obj, context);
 			if (!compiledFormat.check(encoded)) {
-				fail(0xac0 /* Encoded schema should validate */);
+				fail(0xac0 /* Encoded data should validate */);
 			}
 			return encoded;
 		},
 		decode: (encoded: TValidate, context: TContext): TInMemoryFormat => {
 			if (!compiledFormat.check(encoded)) {
-				fail(0xac1 /* Encoded schema should validate */);
+				fail(0xac1 /* Data being decoded should validate */);
 			}
-			// TODO: would be nice to provide a more specific validate type to the inner codec than the outer one gets.
-			return codec.decode(encoded, context) as unknown as TInMemoryFormat;
+			return codec.decode(encoded, context);
 		},
 	};
 }

package/src/codec/index.ts

@@ -42,4 +42,5 @@ export {
 	ClientVersionDispatchingCodecBuilder,
 	type CodecVersion,
 	type CodecAndSchema,
+	versionField,
 } from "./versioned/index.js";

package/src/codec/versioned/codec.ts

@@ -38,6 +38,12 @@ import { Versioned } from "./format.js";
  */
 type VersionedJson = JsonCompatibleReadOnlyObject & Versioned;
 
+/**
+ * Validate that the version is one of the supported values.
+ * @remarks
+ * If supportedVersions contains undefined, data with no version field is also accepted despite the return type indicating otherwise.
+ * This is for legacy compatibility where older data may not have a version field.
+ */
 function makeVersionedCodec<
 	TDecoded,
 	TEncoded extends Versioned = VersionedJson,
@@ -70,12 +76,21 @@ The client which encoded this data likely specified an "minVersionForCollab" val
 		},
 	};
 
-	return supportedVersions.has(undefined)
-		? codec
-		: withSchemaValidation(Versioned, codec, validator);
+	// If undefined is a supported version, skip using withSchemaValidation to enforce there is a version field.
+	// Codec will still assert the content of the field is in supportedVersions, so it is still somewhat validated, just in a different way.
+	if (supportedVersions.has(undefined)) {
+		return codec;
+	}
+
+	return withSchemaValidation(Versioned, codec, validator);
 }
 
 /**
+ * Wrap a codec with version checking and schema validation.
+ * @remarks
+ * The passed in codec should not perform its own schema validation.
+ * The schema validation gets added here.
+ *
  * TODO: users of this should migrate to {@link ClientVersionDispatchingCodecBuilder}.
  */
 export function makeVersionedValidatedCodec<
@@ -376,9 +391,19 @@ export class ClientVersionDispatchingCodecBuilder<
 	/**
 	 * Produce a single codec which can read any supported format, and writes a version selected based on the provided options.
 	 */
-	public build(
-		options: TBuildOptions,
-	): IJsonCodec<TDecoded, JsonCompatibleReadOnly, JsonCompatibleReadOnly, TContext> {
+	public build(options: TBuildOptions): IJsonCodec<
+		TDecoded,
+		JsonCompatibleReadOnly,
+		JsonCompatibleReadOnly,
+		TContext
+	> & {
+		/**
+		 * The format version which this codec writes.
+		 * @remarks
+		 * This is selected based on the provided {@link CodecWriteOptions}.
+		 */
+		readonly writeVersion: TFormatVersion;
+	} {
 		const applied = this.applyOptions(options);
 		const writeVersion = getWriteVersion(this.name, options, applied);
 		const fromFormatVersion = new Map<
@@ -400,6 +425,7 @@ The client which encoded this data likely specified an "minVersionForCollab" val
 				}
 				return codec.codec.decode(data, context);
 			},
+			writeVersion: writeVersion.formatVersion,
 		};
 	}
 

package/src/codec/versioned/format.ts

@@ -5,10 +5,25 @@
 
 import { type Static, Type } from "@sinclair/typebox";
 
-export const Versioned = Type.Object({
+/**
+ * A field to use in TypeBox schemas for the version field of a versioned format.
+ * @remarks
+ * Spread this into the top level object schema for the format.
+ * The version field is required for all versioned formats, and is used by the {@link VersionDispatchingCodecBuilder} to determine which codec version to use when decoding.
+ */
+export const versionField = {
 	/**
 	 * String versions are used for formats that are not yet officially supported. See {@link FormatVersion} for details.
+	 * @remarks
+	 * Having this schema be particularly strict is not too important since
+	 * checking that the contents are the exact value expected is done by `makeVersionedCodec` in the {@link VersionDispatchingCodecBuilder}.
 	 */
 	version: Type.Union([Type.Number(), Type.String()]),
-});
+} as const;
+
+/**
+ * An object which has a {@link versionField}.
+ */
+export const Versioned = Type.Object(versionField);
+
 export type Versioned = Static<typeof Versioned>;

package/src/codec/versioned/index.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-export { Versioned } from "./format.js";
+export { Versioned, versionField } from "./format.js";
 export {
 	makeVersionedValidatedCodec,
 	makeVersionDispatchingCodec,

package/src/core/change-family/changeFamily.ts

@@ -14,17 +14,12 @@ export interface ChangeFamily<TEditor extends ChangeFamilyEditor, TChange> {
 	buildEditor(
 		mintRevisionTag: () => RevisionTag,
 		changeReceiver: (change: TaggedChange<TChange>) => void,
-		options?: EditorOptions,
 	): TEditor;
 
 	readonly rebaser: ChangeRebaser<TChange>;
 	readonly codecs: ICodecFamily<TChange, ChangeEncodingContext>;
 }
 
-export interface EditorOptions {
-	readonly enableDetachedRootEditing: boolean; // default is false,
-}
-
 export interface ChangeEncodingContext {
 	readonly originatorId: SessionId;
 	readonly revision: RevisionTag | undefined;

package/src/core/change-family/index.ts

@@ -8,6 +8,5 @@ export type {
 	ChangeFamilyEditor,
 	ChangeEncodingContext,
 	ChangeFamilyCodec,
-	EditorOptions,
 } from "./changeFamily.js";
 export { EditBuilder } from "./editBuilder.js";

package/src/core/index.ts

@@ -74,7 +74,7 @@ export {
 	type AnchorNode,
 	anchorSlot,
 	type UpPathDefault,
-	isDetachedUpPathRoot,
+	isDetachedUpPath,
 	inCursorField,
 	inCursorNode,
 	type AnchorEvents,
@@ -87,7 +87,6 @@ export {
 	type DetachedFieldIndexCheckpoint,
 	type ForestRootId,
 	getDetachedFieldContainingPath,
-	getDetachedFieldContainingFieldPath,
 	aboveRootPlaceholder,
 	type DeltaRoot,
 	type DeltaMark,
@@ -163,7 +162,6 @@ export {
 	type ChangeEncodingContext,
 	type ChangeFamilyEditor,
 	EditBuilder,
-	type EditorOptions,
 } from "./change-family/index.js";
 
 export {
@@ -180,6 +178,8 @@ export {
 	type LocalChangeMetadata,
 	type RemoteChangeMetadata,
 	type ChangeMetadata,
+	type LabelTree,
+	type TransactionLabels,
 	type RevisionTag,
 	RevisionTagSchema,
 	RevisionTagCodec,
@@ -214,7 +214,6 @@ export {
 	isAncestor,
 	type ChangeAtomIdRangeMap,
 	newChangeAtomIdRangeMap,
-	newChangeAtomIdTransform,
 	comparePartialRevisions,
 	compareChangesetLocalIds,
 	comparePartialChangesetLocalIds,
@@ -222,12 +221,6 @@ export {
 	type RevisionReplacer,
 } from "./rebase/index.js";
 
-export {
-	type Adapters,
-	AdaptedViewSchema,
-	type TreeAdapter,
-} from "./schema-view/index.js";
-
 export {
 	type Revertible,
 	RevertibleStatus,

package/src/core/rebase/changeRebaser.ts

@@ -161,12 +161,7 @@ export function mapTaggedChange<TIn, TOut>(
 export type RevisionIndexer = (tag: RevisionTag) => number | undefined;
 
 export interface RevisionMetadataSource {
-	/**
-	 * @returns a positive number if tag2 is a later revision than tag1 or a negative number if tag2 is an earlier revision.
-	 * Returns zero is the order cannot be determined, which happens if both revisions are older
-	 * than the set of revisions handled by this metadata source.
-	 */
-	readonly compareRevisions: (tag1: RevisionTag, tag2: RevisionTag) => number;
+	readonly getIndex: RevisionIndexer;
 	readonly tryGetInfo: (tag: RevisionTag | undefined) => RevisionInfo | undefined;
 	readonly hasRollback: (tag: RevisionTag) => boolean;
 }

package/src/core/rebase/index.ts

@@ -15,6 +15,8 @@ export {
 	type LocalChangeMetadata,
 	type RemoteChangeMetadata,
 	type ChangeMetadata,
+	type LabelTree,
+	type TransactionLabels,
 	type RevisionTag,
 	RevisionTagSchema,
 	type EncodedRevisionTag,
@@ -31,7 +33,6 @@ export {
 	subtractChangeAtomIds,
 	type ChangeAtomIdRangeMap,
 	newChangeAtomIdRangeMap,
-	newChangeAtomIdTransform,
 	comparePartialRevisions,
 	compareChangesetLocalIds,
 	comparePartialChangesetLocalIds,