@fluidframework/tree 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

package/src/treeFactory.ts

@@ -9,27 +9,27 @@ import {
 	IChannelServices,
 	IFluidDataStoreRuntime,
 } from "@fluidframework/datastore-definitions";
+import { ISharedObjectKind } from "@fluidframework/shared-object-base";
+
+import { pkgVersion } from "./packageVersion.js";
 import { SharedTree as SharedTreeImpl, SharedTreeOptions } from "./shared-tree/index.js";
 import { ITree } from "./simple-tree/index.js";
-import { pkgVersion } from "./packageVersion.js";
 
 /**
  * A channel factory that creates an {@link ITree}.
- * @internal
  */
 export class TreeFactory implements IChannelFactory<ITree> {
-	public readonly type: string;
-	public readonly attributes: IChannelAttributes;
+	public static readonly type = "https://graph.microsoft.com/types/tree";
+	public static readonly attributes: IChannelAttributes = {
+		type: this.type,
+		snapshotFormatVersion: "0.0.0",
+		packageVersion: pkgVersion,
+	};
 
-	public constructor(private readonly options: SharedTreeOptions) {
-		this.type = "https://graph.microsoft.com/types/tree";
+	public readonly type = TreeFactory.type;
+	public readonly attributes: IChannelAttributes = TreeFactory.attributes;
 
-		this.attributes = {
-			type: this.type,
-			snapshotFormatVersion: "0.0.0",
-			packageVersion: pkgVersion,
-		};
-	}
+	public constructor(private readonly options: SharedTreeOptions) {}
 
 	public async load(
 		runtime: IFluidDataStoreRuntime,
@@ -50,21 +50,46 @@ export class TreeFactory implements IChannelFactory<ITree> {
 }
 
 /**
- * SharedTree is a hierarchical data structure for collaboratively editing JSON-like trees
+ * SharedTree is a hierarchical data structure for collaboratively editing strongly typed JSON-like trees
  * of objects, arrays, and other data types.
- *
+ * @public
+ */
+export const SharedTree: ISharedObjectKind<ITree> = configuredSharedTree({});
+
+/**
+ * {@link SharedTree} but allowing a non-default configuration.
  * @remarks
- * This implements {@link @fluidframework/fluid-static#SharedObjectClass}.
+ * This is useful for debugging and testing to opt into extra validation or see if opting out of some optimizations fixes an issue.
+ * @example
+ * ```typescript
+ * import {
+ * 	ForestType,
+ * 	TreeCompressionStrategy,
+ * 	configuredSharedTree,
+ * 	typeboxValidator,
+ * 	// eslint-disable-next-line import/no-internal-modules
+ * } from "@fluidframework/tree/internal";
+ * const SharedTree = configuredSharedTree({
+ * 	forest: ForestType.Reference,
+ * 	jsonValidator: typeboxValidator,
+ * 	treeEncodeType: TreeCompressionStrategy.Uncompressed,
+ * });
+ * ```
  * @privateRemarks
- * Due to the dependency structure and the placement of that interface SharedObjectClass,
- * this interface implementation can not be recorded in the type here.
- * @public
+ * TODO:
+ * Expose Ajv validator for better error message quality somehow.
+ * Maybe as part of a test utils or dev-tool package?
+ * @internal
  */
-export const SharedTree = {
-	/**
-	 * Gets the factory this factory is a wrapper for.
-	 */
-	getFactory(): IChannelFactory<ITree> {
-		return new TreeFactory({});
-	},
-};
+export function configuredSharedTree(options: SharedTreeOptions): ISharedObjectKind<ITree> {
+	const factory = new TreeFactory(options);
+	return {
+		getFactory(): IChannelFactory<ITree> {
+			return factory;
+		},
+
+		create(runtime: IFluidDataStoreRuntime, id?: string): ITree {
+			return runtime.createChannel(id, TreeFactory.type) as ITree;
+		},
+	};
+}

package/src/util/brand.ts

@@ -3,9 +3,9 @@
  * Licensed under the MIT License.
  */
 
-import { NumericOptions, TUnsafe, Type } from "@sinclair/typebox";
-import { Covariant, isAny } from "./typeCheck.js";
-import { Assume } from "./utils.js";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
+import type { Covariant } from "./typeCheck.js";
 
 /**
  * Constructs a "Branded" type, adding a type-checking only field to `ValueType`.
@@ -20,63 +20,12 @@ import { Assume } from "./utils.js";
  * These branded types are not opaque: A `Brand<A, B>` can still be used as a `B`.
  * @internal
  */
-export type Brand<ValueType, Name extends string | ErasedType<string>> = ValueType &
-	BrandedType<ValueType, Name extends Erased<infer TName> ? TName : Assume<Name, string>>;
-
-/**
- * "opaque" handle which can be used to expose a branded type without referencing its value type.
- *
- * Recommended usage is to use `interface` instead of `type` so tooling (such as tsc and refactoring tools)
- * uses the type name instead of expanding it:
- * ```typescript
- * export interface MyType extends Erased<"myPackage.MyType">{}
- * ```
- * @internal
- */
-export type Erased<Name extends string> = ErasedType<Name>;
-
-/**
- * Helper for {@link Erased}.
- * This is split out into its own as that's the only way to:
- * - have doc comments for the member.
- * - make the member protected (so you don't accidentally try and read it).
- * - get nominal typing (so types produced without using this class can never be assignable to it).
- *
- * See `InternalTypes.MakeNominal` for some more details.
- *
- * Do not use this class with `instanceof`: this will always be false at runtime,
- * but the compiler may think it's true in some cases.
- *
- * @sealed
- * @internal
- */
-export abstract class ErasedType<out Name extends string> {
-	/**
-	 * Compile time only marker to make type checking more strict.
-	 * This method will not exist at runtime and accessing it is invalid.
-	 * See {@link Brand} for details.
-	 *
-	 * @privateRemarks
-	 * `Name` is used as the return type of a method rather than a a simple readonly member as this allows types with two brands to be intersected without getting `never`.
-	 * The method takes in never to help emphasize that its not callable.
-	 */
-	protected abstract brand(dummy: never): Name;
-
-	/**
-	 * This class should never exist at runtime, so make it un-constructable.
-	 */
-	private constructor() {}
-}
+export type Brand<ValueType, Name> = ValueType & BrandedType<ValueType, Name>;
 
 /**
  * Helper for {@link Brand}.
- * This is split out into its own as that's the only way to:
- * - have doc comments for the member.
- * - make the member protected (so you don't accidentally try and read it).
- * - get nominal typing (so types produced without using this class can never be assignable to it).
- * - allow use as {@link Opaque} branded type (not assignable to `ValueType`, but captures `ValueType`).
  *
- * See `InternalTypes.MakeNominal` for some more details.
+ * See `MakeNominal` for some more details.
  *
  * Do not use this class with `instanceof`: this will always be false at runtime,
  * but the compiler may think it's true in some cases.
@@ -86,10 +35,16 @@ export abstract class ErasedType<out Name extends string> {
  * This is suitable for when ValueType is immutable (like string or number),
  * which is the common use-case for branding.
  *
+ * @privateRemarks
+ * This is split out into its own type as that's the only way to:
+ *
+ * - make the member protected (so you can't accidentally try and access it).
+ * - get nominal typing (so types produced without using this class can never be assignable to it).
+ *
  * @sealed
  * @internal
  */
-export abstract class BrandedType<out ValueType, Name extends string> {
+export abstract class BrandedType<out ValueType, Name> {
 	protected _typeCheck?: Covariant<ValueType>;
 	/**
 	 * Compile time only marker to make type checking more strict.
@@ -106,49 +61,27 @@ export abstract class BrandedType<out ValueType, Name extends string> {
 	 * This class should never exist at runtime, so make it un-constructable.
 	 */
 	private constructor() {}
-}
 
-/**
- * Converts a Branded type into an "opaque" handle.
- * This prevents the value from being used directly, but does not fully type erase it
- * (and this its not really fully opaque):
- * The type can be recovered using {@link extractFromOpaque},
- * however if we assume only code that produces these "opaque" handles does that conversion,
- * they can function like opaque handles.
- *
- * Recommended usage is to use `interface` instead of `type` so tooling (such as tsc and refactoring tools)
- * uses the type name instead of expanding it:
- * ```typescript
- * export interface MyType extends Opaque<Brand<string, "myPackage.MyType">>{}
- * ```
- * @internal
- */
-export type Opaque<T extends Brand<any, string>> = T extends BrandedType<
-	infer ValueType,
-	infer Name
->
-	? BrandedType<ValueType, Name>
-	: never;
-
-/**
- * See {@link extractFromOpaque}.
- * @internal
- */
-export type ExtractFromOpaque<TOpaque extends BrandedType<any, string>> =
-	TOpaque extends BrandedType<infer ValueType, infer Name>
-		? isAny<ValueType> extends true
-			? unknown
-			: Brand<ValueType, Name>
-		: never;
+	/**
+	 * Since this class is a compile time only type brand, `instanceof` will never work with it.
+	 * This `Symbol.hasInstance` implementation ensures that `instanceof` will error if used,
+	 * and in TypeScript 5.3 and newer will produce a compile time error if used.
+	 */
+	public static [Symbol.hasInstance](value: never): value is never {
+		throw new UsageError(
+			"BrandedType is a compile time type brand not a real class that can be used with `instancof` at runtime.",
+		);
+	}
+}
 
 /**
  * Implementation detail of type branding. Should not be used directly outside this file,
  * but shows up as part of branded types so API-Extractor requires it to be exported.
  * @internal
  */
-export type ValueFromBranded<T extends BrandedType<any, string>> = T extends BrandedType<
+export type ValueFromBranded<T extends BrandedType<unknown, unknown>> = T extends BrandedType<
 	infer ValueType,
-	string
+	unknown
 >
 	? ValueType
 	: never;
@@ -158,93 +91,28 @@ export type ValueFromBranded<T extends BrandedType<any, string>> = T extends Bra
  * but shows up as part of branded types so API-Extractor requires it to be exported.
  * @internal
  */
-export type NameFromBranded<T extends BrandedType<any, string>> = T extends BrandedType<
-	any,
+export type NameFromBranded<T extends BrandedType<unknown, unknown>> = T extends BrandedType<
+	unknown,
 	infer Name
 >
 	? Name
 	: never;
 
-/**
- * Converts a {@link Opaque} handle to the underlying branded type.
- *
- * It is assumed that only code that produces these "opaque" handles does this conversion,
- * allowing these handles to be considered opaque.
- * @internal
- */
-export function extractFromOpaque<TOpaque extends BrandedType<any, string>>(
-	value: TOpaque,
-): ExtractFromOpaque<TOpaque> {
-	return value as ExtractFromOpaque<TOpaque>;
-}
-
-/**
- * Converts a {@link Erased} handle to the underlying branded type.
- *
- * It is assumed that only code that produces these "opaque" handles does this conversion,
- * allowing these handles to be considered opaque.
- * @internal
- */
-export function fromErased<
-	TBranded extends BrandedType<unknown, string>,
-	TName extends string = NameFromBranded<TBranded>,
->(value: ErasedType<TName>): TBranded {
-	return value as unknown as TBranded;
-}
-
 /**
  * Adds a type {@link Brand} to a value.
  *
  * Only do this when specifically allowed by the requirements of the type being converted to.
+ * @privateRemarks
+ * Leaving `T` unconstrained here allows for better type inference when branding unions.
+ * For example when assigning `brand(number)` a number to an optional branded number field,
+ * constraining T to `BrandedType<unknown, string>` causes the inference to fail and requires explicitly providing the type parameter.
+ * For example leaving T unconstrained instead allows the union of `BrandedType | undefined` to distribute over the conditional allowing the branding only the the union members which should be branded.
+ * This does not permit branding an optional value into an optional field since non branded union members are still excluded from input to this function:
+ * this is an intended restriction as it causes compile errors for misuse of this function (like using brand when the relevant type is not a branded type).
  * @internal
  */
-export function brand<T extends Brand<any, string>>(
-	value: T extends BrandedType<infer ValueType, string> ? ValueType : never,
+export function brand<T>(
+	value: T extends BrandedType<infer ValueType, unknown> ? ValueType : never,
 ): T {
 	return value as T;
 }
-
-/**
- * Adds a type {@link Brand} to a value, returning it as a {@link Opaque} handle.
- *
- * Only do this when specifically allowed by the requirements of the type being converted to.
- * @internal
- */
-export function brandOpaque<T extends BrandedType<any, string>>(
-	value: isAny<ValueFromBranded<T>> extends true ? never : ValueFromBranded<T>,
-): BrandedType<ValueFromBranded<T>, NameFromBranded<T>> {
-	return value as BrandedType<ValueFromBranded<T>, NameFromBranded<T>>;
-}
-
-/**
- * Adds a type {@link Brand} to a value, returning it as a {@link Erased} handle.
- *
- * Only do this when specifically allowed by the requirements of the type being converted to.
- * @internal
- */
-export function brandErased<T extends BrandedType<any, string>>(
-	value: isAny<ValueFromBranded<T>> extends true ? never : ValueFromBranded<T>,
-): ErasedType<NameFromBranded<T>> {
-	return value as ErasedType<NameFromBranded<T>>;
-}
-
-/**
- * Create a TypeBox string schema for a branded string type.
- * This only validates that the value is a string,
- * and not that it came from the correct branded type (that information is lost when serialized).
- */
-export function brandedStringType<T extends string>(): TUnsafe<T> {
-	// This could use:
-	// return TypeSystem.CreateType<T>(name, (options, value) => typeof value === "string")();
-	// Since there isn't any useful custom validation to do and
-	// TUnsafe is documented as unsupported in `typebox/compiler`,
-	// opt for the compile time behavior like the above, but the runtime behavior of the built in string type.
-	return Type.String() as unknown as TUnsafe<T>;
-}
-
-export function brandedNumberType<T extends number>(
-	options?: NumericOptions<number> | undefined,
-): TUnsafe<T> {
-	// See comments on `brandedStringType`.
-	return Type.Number(options) as unknown as TUnsafe<T>;
-}

package/src/util/idAllocator.ts

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
+
 import { fail } from "./utils.js";
 
 /**

package/src/util/index.ts

@@ -3,23 +3,9 @@
  * Licensed under the MIT License.
  */
 
-export {
-	brand,
-	Brand,
-	BrandedType,
-	brandOpaque,
-	brandedNumberType,
-	brandedStringType,
-	extractFromOpaque,
-	ExtractFromOpaque,
-	fromErased,
-	Erased,
-	ErasedType,
-	NameFromBranded,
-	Opaque,
-	ValueFromBranded,
-	brandErased,
-} from "./brand.js";
+export { brand, Brand, BrandedType, NameFromBranded, ValueFromBranded } from "./brand.js";
+export { brandedNumberType, brandedStringType } from "./typeboxBrand.js";
+export { brandOpaque, extractFromOpaque, ExtractFromOpaque, Opaque } from "./opaque.js";
 export {
 	deleteFromNestedMap,
 	getOrAddInMap,
@@ -73,7 +59,6 @@ export {
 	Populated,
 	RecursiveReadonly,
 	zipIterables,
-	Assume,
 	assertValidIndex,
 	assertValidRange,
 	assertNonNegativeSafeInteger,
@@ -100,6 +85,7 @@ export {
 	FlattenKeys,
 	AllowOptionalNotFlattened,
 	RestrictiveReadonlyRecord,
+	Assume,
 } from "./typeUtils.js";
 
 export {

package/src/util/nestedSet.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { getOrDefaultInNestedMap, NestedMap, setInNestedMap } from "./nestedMap.js";
+import { NestedMap, getOrDefaultInNestedMap, setInNestedMap } from "./nestedMap.js";
 
 export type NestedSet<Key1, Key2> = NestedMap<Key1, Key2, boolean>;
 

package/src/util/opaque.ts

@@ -0,0 +1,68 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { Brand, BrandedType, NameFromBranded, ValueFromBranded } from "./brand.js";
+import type { isAny } from "./typeCheck.js";
+
+/**
+ * Converts a Branded type into an "opaque" handle.
+ * This prevents the value from being used directly, but does not fully type erase it.
+ * @remarks
+ * Like {@link @fluidframework/core-interfaces#ErasedType},
+ * but more type safe and cannot be used to hide the internal type from API extractor at package boundaries.
+ *
+ * The type can be recovered using {@link extractFromOpaque},
+ * however if we assume only code that produces these "opaque" handles does that conversion,
+ * they can function like opaque handles.
+ *
+ * Recommended usage is to use `interface` instead of `type` so tooling (such as tsc and refactoring tools)
+ * uses the type name instead of expanding it:
+ * ```typescript
+ * export interface MyType extends Opaque<Brand<string, "myPackage.MyType">>{}
+ * ```
+ * @internal
+ */
+export type Opaque<T extends Brand<any, unknown>> = T extends BrandedType<
+	infer ValueType,
+	infer Name
+>
+	? BrandedType<ValueType, Name>
+	: never;
+
+/**
+ * See {@link extractFromOpaque}.
+ * @internal
+ */
+export type ExtractFromOpaque<TOpaque extends BrandedType<any, unknown>> =
+	TOpaque extends BrandedType<infer ValueType, infer Name>
+		? isAny<ValueType> extends true
+			? unknown
+			: Brand<ValueType, Name>
+		: never;
+
+/**
+ * Converts a {@link Opaque} handle to the underlying branded type.
+ *
+ * It is assumed that only code that produces these "opaque" handles does this conversion,
+ * allowing these handles to be considered opaque.
+ * @internal
+ */
+export function extractFromOpaque<TOpaque extends BrandedType<any, unknown>>(
+	value: TOpaque,
+): ExtractFromOpaque<TOpaque> {
+	return value as ExtractFromOpaque<TOpaque>;
+}
+
+/**
+ * Adds a type {@link Brand} to a value, returning it as a {@link Opaque} handle.
+ *
+ * Only do this when specifically allowed by the requirements of the type being converted to.
+ * @internal
+ */
+export function brandOpaque<T extends BrandedType<any, unknown>>(
+	value: isAny<ValueFromBranded<T>> extends true ? never : ValueFromBranded<T>,
+): BrandedType<ValueFromBranded<T>, NameFromBranded<T>> {
+	return value as BrandedType<ValueFromBranded<T>, NameFromBranded<T>>;
+}

package/src/util/referenceCounting.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
 
 export interface ReferenceCounted {
 	referenceAdded(): void;
@@ -32,7 +32,7 @@ export abstract class ReferenceCountedBase implements ReferenceCounted {
 		this.refCount -= count;
 		assert(this.refCount >= 0, 0x4c4 /* Negative ref count */);
 		if (this.refCount === 0) {
-			this.dispose();
+			this.onUnreferenced();
 		}
 	}
 
@@ -47,5 +47,5 @@ export abstract class ReferenceCountedBase implements ReferenceCounted {
 	/**
 	 * Called when refcount reaches 0.
 	 */
-	protected abstract dispose(): void;
+	protected abstract onUnreferenced(): void;
 }

package/src/util/typeCheckTests.ts

@@ -9,18 +9,18 @@
 /* eslint-disable @typescript-eslint/ban-types */
 /* eslint-disable @typescript-eslint/no-extraneous-class */
 
-import {
-	MakeNominal,
-	Covariant,
+import type {
 	Contravariant,
+	Covariant,
 	Invariant,
-	requireTrue,
-	requireFalse,
-	isAssignableTo,
+	MakeNominal,
 	areSafelyAssignable,
-	isAny,
 	eitherIsAny,
+	isAny,
+	isAssignableTo,
 	isStrictSubset,
+	requireFalse,
+	requireTrue,
 } from "./typeCheck.js";
 
 /**

package/src/util/typeUtils.ts

@@ -166,3 +166,17 @@ export type _RecursiveTrick = never;
 export type RestrictiveReadonlyRecord<K extends symbol | string, T> = {
 	readonly [P in symbol | string]: P extends K ? T : never;
 };
+
+/**
+ * Assume that `TInput` is a `TAssumeToBe`.
+ *
+ * @remarks
+ * This is useful in generic code when it is impractical (or messy)
+ * to to convince the compiler that a generic type `TInput` will extend `TAssumeToBe`.
+ * In these cases `TInput` can be replaced with `Assume<TInput, TAssumeToBe>` to allow compilation of the generic code.
+ * When the generic code is parameterized with a concrete type, if that type actually does extend `TAssumeToBe`,
+ * it will behave like `TInput` was used directly.
+ *
+ * @internal
+ */
+export type Assume<TInput, TAssumeToBe> = [TInput] extends [TAssumeToBe] ? TInput : TAssumeToBe;

package/src/util/typeboxBrand.ts

@@ -0,0 +1,31 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { NumericOptions, TUnsafe, Type } from "@sinclair/typebox";
+
+/**
+ * Create a TypeBox string schema for a branded string type.
+ * This only validates that the value is a string,
+ * and not that it came from the correct branded type (that information is lost when serialized).
+ */
+export function brandedStringType<T extends string>(): TUnsafe<T> {
+	// This could use:
+	// return TypeSystem.CreateType<T>(name, (options, value) => typeof value === "string")();
+	// Since there isn't any useful custom validation to do and
+	// TUnsafe is documented as unsupported in `typebox/compiler`,
+	// opt for the compile time behavior like the above, but the runtime behavior of the built in string type.
+	return Type.String() as unknown as TUnsafe<T>;
+}
+
+/**
+ * Create a TypeBox number schema for a branded string type.
+ * {@link brandedStringType} but for numbers.
+ */
+export function brandedNumberType<T extends number>(
+	options?: NumericOptions<number> | undefined,
+): TUnsafe<T> {
+	// See comments on `brandedStringType`.
+	return Type.Number(options) as unknown as TUnsafe<T>;
+}

package/src/util/utils.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
 import { Type } from "@sinclair/typebox";
 import structuredClone from "@ungap/structured-clone";
 
@@ -294,20 +294,6 @@ export function assertNonNegativeSafeInteger(index: number) {
 	assert(index >= 0, 0x377 /* index must be non-negative */);
 }
 
-/**
- * Assume that `TInput` is a `TAssumeToBe`.
- *
- * @remarks
- * This is useful in generic code when it is impractical (or messy)
- * to to convince the compiler that a generic type `TInput` will extend `TAssumeToBe`.
- * In these cases `TInput` can be replaced with `Assume<TInput, TAssumeToBe>` to allow compilation of the generic code.
- * When the generic code is parameterized with a concrete type, if that type actually does extend `TAssumeToBe`,
- * it will behave like `TInput` was used directly.
- *
- * @internal
- */
-export type Assume<TInput, TAssumeToBe> = [TInput] extends [TAssumeToBe] ? TInput : TAssumeToBe;
-
 /**
  * Convert an object into a Map.
  *
@@ -409,8 +395,8 @@ export function compareNamed(a: Named<string>, b: Named<string>): -1 | 0 | 1 {
 
 /**
  * Placeholder for `Symbol.dispose`.
- *
- * Replace this with `Symbol.dispose` when it is available.
+ * @privateRemarks
+ * TODO: replace this with `Symbol.dispose` when it is available or make it a valid polyfill.
  * @public
  */
 export const disposeSymbol: unique symbol = Symbol("Symbol.dispose placeholder");

package/tsconfig.json

@@ -14,7 +14,7 @@
 		// Linter is used to enforce "_" prefix for unused locals to prevent accidentally having unused locals.
 		"noUnusedLocals": false,
 		"noImplicitOverride": true,
-		"lib": ["ES2020", "ES2022.Array", "DOM", "DOM.Iterable"],
+		"lib": ["ES2020", "DOM", "DOM.Iterable"],
 	},
 	"include": ["src/**/*"],
 }

package/api-extractor-cjs.json

@@ -1,18 +0,0 @@
-{
-	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-	"extends": "../../../common/build/build-common/api-extractor-base.cjs.primary.json",
-	"compiler": {
-		// api-extractor has trouble with Node16 moduleResolution, but Bundler looks okay.
-		"overrideTsconfig": {
-			"$schema": "http://json.schemastore.org/tsconfig",
-			"extends": "./tsconfig.json",
-			"compilerOptions": {
-				"moduleResolution": "Bundler"
-			}
-		}
-	},
-	// CJS is actually secondary; so, no report.
-	"apiReport": {
-		"enabled": false
-	}
-}