@fluidframework/tree 2.0.0-dev-rc.5.0.0.271262 → 2.0.0-dev-rc.5.0.0.272251

package/src/shared-tree-core/branch.ts

@@ -120,6 +120,27 @@ export interface SharedTreeBranchEvents<TEditor extends ChangeFamilyEditor, TCha
 	 * Fired after this branch is disposed
 	 */
 	dispose(): void;
+
+	/**
+	 * Fired after a new transaction is started.
+	 * @param isOuterTransaction - true iff the transaction being started is the outermost transaction
+	 * as opposed to a nested transaction.
+	 */
+	transactionStarted(isOuterTransaction: boolean): void;
+
+	/**
+	 * Fired after the current transaction is aborted.
+	 * @param isOuterTransaction - true iff the transaction being aborted is the outermost transaction
+	 * as opposed to a nested transaction.
+	 */
+	transactionAborted(isOuterTransaction: boolean): void;
+
+	/**
+	 * Fired after the current transaction is committed.
+	 * @param isOuterTransaction - true iff the transaction being committed is the outermost transaction
+	 * as opposed to a nested transaction.
+	 */
+	transactionCommitted(isOuterTransaction: boolean): void;
 }
 
 /**
@@ -267,6 +288,7 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> exten
 			onForkUnSubscribe();
 		});
 		this.editor.enterTransaction();
+		this.emit("transactionStarted", this.transactions.size === 1);
 	}
 
 	/**
@@ -283,6 +305,7 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> exten
 		const [startCommit, commits] = this.popTransaction();
 		this.editor.exitTransaction();
 
+		this.emit("transactionCommitted", this.transactions.size === 0);
 		if (commits.length === 0) {
 			return undefined;
 		}
@@ -329,6 +352,7 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> exten
 		const [startCommit, commits] = this.popTransaction();
 		this.editor.exitTransaction();
 
+		this.emit("transactionAborted", this.transactions.size === 0);
 		if (commits.length === 0) {
 			return [undefined, []];
 		}

package/src/shared-tree-core/branchCommitEnricher.ts

@@ -12,8 +12,7 @@ import { TransactionEnricher } from "./transactionEnricher.js";
  * Utility for enriching commits from a {@link Branch} before these commits are applied and submitted.
  */
 export class BranchCommitEnricher<TChange> {
-	private transactionEnricher?: TransactionEnricher<TChange>;
-	private readonly rebaser: ChangeRebaser<TChange>;
+	private readonly transactionEnricher: TransactionEnricher<TChange>;
 	private readonly enricher: ChangeEnricherReadonlyCheckout<TChange>;
 	/**
 	 * Maps each local commit to the corresponding enriched commit.
@@ -28,8 +27,8 @@ export class BranchCommitEnricher<TChange> {
 		rebaser: ChangeRebaser<TChange>,
 		enricher: ChangeEnricherReadonlyCheckout<TChange>,
 	) {
-		this.rebaser = rebaser;
 		this.enricher = enricher;
+		this.transactionEnricher = new TransactionEnricher(rebaser, this.enricher);
 	}
 
 	/**
@@ -39,6 +38,18 @@ export class BranchCommitEnricher<TChange> {
 		return this.preparedCommits.size;
 	}
 
+	public startNewTransaction(): void {
+		this.transactionEnricher.startNewTransaction();
+	}
+
+	public commitCurrentTransaction(): void {
+		this.transactionEnricher.commitCurrentTransaction();
+	}
+
+	public abortCurrentTransaction(): void {
+		this.transactionEnricher.abortCurrentTransaction();
+	}
+
 	/**
 	 * Adds a commit to the enricher.
 	 * @param commit - A commit that is part of a transaction.
@@ -46,8 +57,7 @@ export class BranchCommitEnricher<TChange> {
 	public ingestTransactionCommit(commit: GraphCommit<TChange>): void {
 		// We do not submit ops for changes that are part of a transaction.
 		// But we need to enrich the commits that will be sent if the transaction is committed.
-		this.transactionEnricher ??= new TransactionEnricher(this.rebaser, this.enricher);
-		this.transactionEnricher.addTransactionSteps(commit);
+		this.transactionEnricher.addTransactionStep(commit);
 	}
 
 	/**
@@ -66,7 +76,6 @@ export class BranchCommitEnricher<TChange> {
 				"Unexpected transaction commit without transaction steps",
 			);
 			enrichedChange = this.transactionEnricher.getComposedChange(commit.revision);
-			delete this.transactionEnricher;
 		} else {
 			enrichedChange = this.enricher.updateChangeEnrichments(commit.change, commit.revision);
 		}

package/src/shared-tree-core/sharedTreeCore.ts

@@ -151,6 +151,15 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange> extends
 		 */
 		const localSessionId = runtime.idCompressor.localSessionId;
 		this.editManager = new EditManager(changeFamily, localSessionId, this.mintRevisionTag);
+		this.editManager.localBranch.on("transactionStarted", () => {
+			this.commitEnricher.startNewTransaction();
+		});
+		this.editManager.localBranch.on("transactionAborted", () => {
+			this.commitEnricher.abortCurrentTransaction();
+		});
+		this.editManager.localBranch.on("transactionCommitted", () => {
+			this.commitEnricher.commitCurrentTransaction();
+		});
 		this.editManager.localBranch.on("beforeChange", (change) => {
 			// Ensure that any previously prepared commits that have not been sent are purged.
 			this.commitEnricher.purgePreparedCommits();

package/src/shared-tree-core/transactionEnricher.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import { assert } from "@fluidframework/core-utils/internal";
 import type { ChangeRebaser, GraphCommit, RevisionTag } from "../core/index.js";
 import type { ChangeEnricherReadonlyCheckout } from "./changeEnricher.js";
 
@@ -13,6 +14,13 @@ export class TransactionEnricher<TChange> {
 	private readonly rebaser: ChangeRebaser<TChange>;
 	private readonly enricher: ChangeEnricherReadonlyCheckout<TChange>;
 	private readonly transactionCommits: GraphCommit<TChange>[] = [];
+	/**
+	 * The number of commits before the start of each active transaction scope.
+	 * For a stack of `n` transaction scopes, the array will contain `n` integers,
+	 * where the integer at index `i` is the number of commits made before the start of the `i`th transaction scope
+	 * (therefore, the first element in the array, if present, is always 0)
+	 */
+	private readonly transactionScopesStart: number[] = [];
 
 	public constructor(
 		rebaser: ChangeRebaser<TChange>,
@@ -22,14 +30,32 @@ export class TransactionEnricher<TChange> {
 		this.enricher = enricher;
 	}
 
-	public addTransactionSteps(commit: GraphCommit<TChange>): void {
+	public startNewTransaction(): void {
+		this.transactionScopesStart.push(this.transactionCommits.length);
+	}
+
+	public commitCurrentTransaction(): void {
+		const commitsCommitted = this.transactionScopesStart.pop();
+		assert(commitsCommitted !== undefined, "No transaction to commit");
+	}
+
+	public abortCurrentTransaction(): void {
+		const scopeStart = this.transactionScopesStart.pop();
+		assert(scopeStart !== undefined, "No transaction to abort");
+		this.transactionCommits.length = scopeStart;
+	}
+
+	public addTransactionStep(commit: GraphCommit<TChange>): void {
+		assert(this.transactionScopesStart.length !== 0, "No transaction to add a step to");
 		const change = this.enricher.updateChangeEnrichments(commit.change, commit.revision);
 		this.transactionCommits.push({ ...commit, change });
 	}
 
 	public getComposedChange(revision: RevisionTag): TChange {
+		assert(this.transactionScopesStart.length === 0, "Transaction not committed");
 		const squashed = this.rebaser.compose(this.transactionCommits);
 		const tagged = this.rebaser.changeRevision(squashed, revision);
+		this.transactionCommits.length = 0;
 		return tagged;
 	}
 }

package/src/simple-tree/arrayNode.ts

@@ -376,34 +376,34 @@ declare abstract class NodeWithArrayFeatures<Input, T>
 {
 	concat(...items: ConcatArray<T>[]): T[];
 	concat(...items: (T | ConcatArray<T>)[]): T[];
-	join(separator?: string | undefined): string;
-	slice(start?: number | undefined, end?: number | undefined): T[];
-	indexOf(searchElement: T, fromIndex?: number | undefined): number;
-	lastIndexOf(searchElement: T, fromIndex?: number | undefined): number;
+	entries(): IterableIterator<[number, T]>;
 	every<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): this is readonly S[];
 	every(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
-	some(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
-	forEach(callbackfn: (value: T, index: number, array: readonly T[]) => void, thisArg?: any): void;
-	map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
 	filter<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S[];
 	filter(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T[];
+	find<S extends T>(predicate: (value: T, index: number, obj: readonly T[]) => value is S, thisArg?: any): S | undefined;
+	find(predicate: (value: T, index: number, obj: readonly T[]) => unknown, thisArg?: any): T | undefined;
+	findIndex(predicate: (value: T, index: number, obj: readonly T[]) => unknown, thisArg?: any): number;
+	flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
+	flatMap<U, This = undefined>(callback: (this: This, value: T, index: number, array: T[]) => U | readonly U[], thisArg?: This | undefined): U[];
+	forEach(callbackfn: (value: T, index: number, array: readonly T[]) => void, thisArg?: any): void;
+	includes(searchElement: T, fromIndex?: number | undefined): boolean;
+	indexOf(searchElement: T, fromIndex?: number | undefined): number;
+	join(separator?: string | undefined): string;
+	keys(): IterableIterator<number>;
+	lastIndexOf(searchElement: T, fromIndex?: number | undefined): number;
+	map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
 	reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
 	reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
 	reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
 	reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
 	reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
 	reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
-	find<S extends T>(predicate: (value: T, index: number, obj: readonly T[]) => value is S, thisArg?: any): S | undefined;
-	find(predicate: (value: T, index: number, obj: readonly T[]) => unknown, thisArg?: any): T | undefined;
-	findIndex(predicate: (value: T, index: number, obj: readonly T[]) => unknown, thisArg?: any): number;
-	entries(): IterableIterator<[number, T]>;
-	keys(): IterableIterator<number>;
-	values(): IterableIterator<T>;
-	includes(searchElement: T, fromIndex?: number | undefined): boolean;
-	flatMap<U, This = undefined>(callback: (this: This, value: T, index: number, array: T[]) => U | readonly U[], thisArg?: This | undefined): U[];
-	flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
-	toString(): string;
+	slice(start?: number | undefined, end?: number | undefined): T[];
+	some(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
 	toLocaleString(): string;
+	toString(): string;
+	values(): IterableIterator<T>;
 }
 /* eslint-enable @typescript-eslint/explicit-member-accessibility, @typescript-eslint/no-explicit-any */
 

package/src/simple-tree/schemaFactory.ts

@@ -567,11 +567,24 @@ export class SchemaFactory<
 	}
 
 	/**
-	 * Make a field of type identifier instead of the default, which is required.
-	 * @remarks Identifiers may be optionally supplied at node construction time.
-	 * If not supplied, they will be generated automatically when the node is inserted into the tree.
-	 * Attempting to read an automatically generated identifier before the node is inserted into the tree will throw an error.
-	 * An automatically generated identifier will not be present when iterating the nodes's fields until after the node is inserted into the tree.
+	 * A special field which holds a unique identifier for an object node.
+	 * @remarks
+	 * The value of this field, a "node identifier", uniquely identifies a node among all other nodes in the tree.
+	 * Node identifiers are strings, and can therefore be used as lookup keys in maps or written to a database.
+	 * When the node is constructed, the identifier field does not need to be populated.
+	 * The SharedTree will provide an identifier for the node automatically.
+	 * An identifier provided automatically by the SharedTree has the following properties:
+	 * - It is a UUID.
+	 * - It is compressed to a space-efficient representation when stored in the document.
+	 * - A compressed form of the identifier can be accessed at runtime via the `Tree.shortId()` API.
+	 * - It will error if read (and will not be present in the object's iterable properties) before the node has been inserted into the tree.
+	 *
+	 * However, a user may alternatively supply their own string as the identifier if desired (for example, if importing identifiers from another system).
+	 * In that case, it is up to the user to ensure that the identifier is unique within the current tree - no other node should have the same identifier at the same time.
+	 * If the identifier is not unique, it may be read, but may cause libraries or features which operate over node identifiers to misbehave.
+	 * User-supplied identifiers may be read immediately, even before insertion into the tree.
+	 *
+	 * A node may have more than one identifier field (though note that this precludes the use of the `Tree.shortId()` API).
 	 */
 	public get identifier(): FieldSchema<FieldKind.Identifier, typeof this.string> {
 		const defaultIdentifierProvider: DefaultProvider = getDefaultProvider(

package/src/simple-tree/tree.ts

@@ -57,30 +57,10 @@ export interface ITree extends IFluidLoadable {
 	viewWith<TRoot extends ImplicitFieldSchema>(
 		config: TreeViewConfiguration<TRoot>,
 	): TreeView<TRoot>;
-
-	/**
-	 * Returns a {@link TreeView} using the provided schema.
-	 * If the stored schema is view-compatible with the view schema specified by `config`,
-	 * the returned {@link TreeView} will expose the root with a schema-aware API based on the provided view schema.
-	 * See {@link TreeView.compatibility} for information about the compatibility between the view and stored schemas.
-	 *
-	 * @remarks
-	 * If the tree is uninitialized, it will be implicitly initialized by this function.
-	 *
-	 * Note that other clients can modify the document at any time, causing the view to change its compatibility status: see {@link TreeView.events} for how to handle invalidation in these cases.
-	 *
-	 * Only one schematized view may exist for a given ITree at a time.
-	 * If creating a second, the first must be disposed before calling `schematize` again.
-	 * @deprecated Replaced by {@link ITree.viewWith}. Use that method instead. Note that `viewWith` does not implicitly initialize the tree:
-	 * to initialize it, call {@link TreeView.initialize} on the returned view.
-	 */
-	schematize<TRoot extends ImplicitFieldSchema>(
-		config: TreeConfiguration<TRoot>,
-	): TreeView<TRoot>;
 }
 
 /**
- * Options when schematizing a tree.
+ * Options when constructing a tree view.
  * @public
  */
 export interface ITreeConfigurationOptions {
@@ -342,11 +322,6 @@ export interface SchemaCompatibilityStatus {
  * @public
  */
 export interface TreeViewEvents {
-	/**
-	 * A batch of changes has finished processing and the view has been updated.
-	 */
-	afterBatch(): void;
-
 	/**
 	 * Raised whenever {@link TreeView.root} is invalidated.
 	 *

package/src/simple-tree/treeNodeApi.ts

@@ -36,6 +36,7 @@ import {
 	stringSchema,
 } from "./leafNodeSchema.js";
 import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 /**
  * Provides various functions for analyzing {@link TreeNode}s.
@@ -101,11 +102,20 @@ export interface TreeNodeApi {
 	readonly status: (node: TreeNode) => TreeStatus;
 
 	/**
-	 * Returns the {@link FieldKind.Identifier | identifier} of the given node in the most compressed form possible.
+	 * Returns the {@link SchemaFactory.identifier | identifier} of the given node in the most compressed form possible.
 	 * @remarks
-	 * If the node's identifier is a valid `StableNodeKey`, then this will return a unique process-local integer corresponding to that identifier.
-	 * If the node's identifier is any other string, then this will return that string.
-	 * If the node has no identifier (that is, it has no field of an {@link FieldKind.Identifier | identifier} field kind), then this returns undefined.
+	 * If the node's identifier is a valid UUID that was automatically generated by the SharedTree, then this will return a process-unique integer corresponding to that identifier.
+	 * This is useful for performance-sensitive scenarios involving many nodes with identifiers that need to be compactly retained in memory or used for efficient lookup.
+	 *
+	 * If the node's identifier is any other user-provided string, then this will return that string.
+	 *
+	 * If the node has no identifier (that is, it has no {@link SchemaFactory.identifier | identifier} field), then this returns `undefined`.
+	 *
+	 * If the node has more than one identifier, then this will throw an error.
+	 *
+	 * The returned integer must not be serialized or preserved outside of the current process.
+	 * Its lifetime is that of the current in-memory instance of the FF container for this client, and it is not guaranteed to be unique or stable outside of that context.
+	 * The same node's identifier may, for example, be different across multiple sessions for the same client and document, or different across two clients in the same session.
 	 */
 	shortId(node: TreeNode): number | string | undefined;
 }
@@ -188,18 +198,26 @@ export const treeNodeApi: TreeNodeApi = {
 	},
 	shortId(node: TreeNode): number | string | undefined {
 		const flexNode = getFlexNode(node);
+		let shortId: number | string | undefined;
 		for (const field of flexNode.boxedIterator()) {
 			if (field.schema.kind === FieldKinds.identifier) {
+				if (shortId !== undefined) {
+					throw new UsageError(
+						"shortId() may not be called on a node with more than one identifier. Consider converting extraneous identifier fields to string fields.",
+					);
+				}
 				const identifier = field.boxedAt(0);
 				assert(identifier !== undefined, 0x927 /* The identifier must exist */);
 				const identifierValue = identifier.value as string;
 				const localNodeKey =
 					identifier.context.nodeKeyManager.tryLocalizeNodeKey(identifierValue);
-				return localNodeKey !== undefined
-					? extractFromOpaque(localNodeKey)
-					: identifierValue;
+
+				shortId =
+					localNodeKey !== undefined ? extractFromOpaque(localNodeKey) : identifierValue;
 			}
 		}
+
+		return shortId;
 	},
 };
 

package/src/simple-tree/types.ts

@@ -6,7 +6,7 @@
 import type { ErasedType } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 
-import { type TreeNodeSchema, type WithType, type } from "./schemaTypes.js";
+import { NodeKind, type TreeNodeSchema, type WithType, type } from "./schemaTypes.js";
 import {
 	type FlexTreeNode,
 	type MapTreeNode,
@@ -19,6 +19,7 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { getFlexSchema } from "./toFlexSchema.js";
 import { fail } from "../util/index.js";
 import { setFlexNode } from "./proxyBinding.js";
+import { tryGetSchema } from "./treeNodeApi.js";
 
 /**
  * Type alias to document which values are un-hydrated.
@@ -32,7 +33,7 @@ import { setFlexNode } from "./proxyBinding.js";
 export type Unhydrated<T> = T;
 
 /**
- * A non-leaf SharedTree node. Includes objects, arrays, and maps.
+ * A non-{@link NodeKind.Leaf|leaf} SharedTree node. Includes objects, arrays, and maps.
  *
  * @remarks
  * Base type which all nodes implement.
@@ -50,11 +51,8 @@ export type Unhydrated<T> = T;
  *
  * Not all node implementations include this in their prototype chain (some hide it with a proxy),
  * and thus cause the default/built in `instanceof` to return false despite our type checking and all other APIs treating them as TreeNodes.
- * This results in the runtime and compile time behavior of `instanceof` differing.
- * TypeScript 5.3 allows altering the compile time behavior of `instanceof`.
- * The runtime behavior can be changed by implementing `Symbol.hasInstance`.
- * One of those approaches could be used to resolve this inconsistency,
- * but for now the type-only export prevents use of `instanceof` avoiding this problem in the public API.
+ * This class provides a custom `Symbol.hasInstance` to fix `instanceof` for this class and all classes extending it.
+ * For now the type-only export prevents use of `instanceof` on this class (but allows it in subclasses like schema classes).
  * @public
  */
 export abstract class TreeNode implements WithType {
@@ -80,7 +78,7 @@ export abstract class TreeNode implements WithType {
 	 * Another option would be to use a symbol (possibly as a private field).
 	 * That approach ran into some strange difficulties causing SchemaFactory to fail to compile, and was not investigated further.
 	 *
-	 * The [type] symbol here provides a lot of the value this private brand does, but is not all of it:
+	 * The [type] symbol provides a lot of the value this private brand does, but is not all of it:
 	 * someone could manually (or via Intellisense auto-implement completion, or in response to a type error)
 	 * make an object literal with the [type] field and pass it off as a node: this private brand prevents that.
 	 */
@@ -93,13 +91,63 @@ export abstract class TreeNode implements WithType {
 	 */
 	public abstract get [type](): string;
 
+	/**
+	 * Provides `instanceof` support for testing if a value is a `TreeNode`.
+	 * @remarks
+	 * For more options, like including leaf values or narrowing to collections of schema, use `is` or `schema` from {@link TreeNodeApi}.
+	 * @privateRemarks
+	 * Due to type-only export, this functionality is not available outside the package.
+	 */
+	public static [Symbol.hasInstance](value: unknown): value is TreeNode;
+
+	/**
+	 * Provides `instanceof` support for all schema classes with public constructors.
+	 * @remarks
+	 * For more options, like including leaf values or narrowing to collections of schema, use `is` or `schema` from {@link TreeNodeApi}.
+	 * @privateRemarks
+	 * Despite type-only export, this functionality is available outside the package since it is inherited by subclasses.
+	 */
+	public static [Symbol.hasInstance]<TSchema extends abstract new (...args: any[]) => TreeNode>(
+		this: TSchema,
+		value: unknown,
+	): value is InstanceType<TSchema>;
+
+	public static [Symbol.hasInstance](this: { prototype: object }, value: unknown): boolean {
+		const schema = tryGetSchema(value);
+
+		if (schema === undefined || schema.kind === NodeKind.Leaf) {
+			return false;
+		}
+
+		assert("prototype" in schema, "expected class based schema");
+		return inPrototypeChain(schema.prototype, this.prototype);
+	}
+
 	protected constructor() {
-		if (!(this instanceof TreeNodeValid)) {
+		if (!inPrototypeChain(Reflect.getPrototypeOf(this), TreeNodeValid.prototype)) {
 			throw new UsageError("TreeNodes must extend schema classes created by SchemaFactory");
 		}
 	}
 }
 
+/**
+ * Check if the prototype derived's prototype chain contains `base`.
+ * @param derived - prototype to check
+ * @param base - prototype to search for
+ * @returns true iff `base` is in the prototype chain starting at `derived`.
+ */
+// eslint-disable-next-line @rushstack/no-new-null
+export function inPrototypeChain(derived: object | null, base: object): boolean {
+	let checking = derived;
+	while (checking !== null) {
+		if (base === checking) {
+			return true;
+		}
+		checking = Reflect.getPrototypeOf(checking);
+	}
+	return false;
+}
+
 /**
  * Class which all {@link TreeNode}s must extend.
  * Since this is not exported, it allows robust detection of attempts to create TreeNodes which do not go through SchemaFactory which is the only place which exposes classes that extend this.

package/tsdoc.json

@@ -0,0 +1,4 @@
+{
+	"$schema": "https://developer.microsoft.com/json-schemas/tsdoc/v0/tsdoc.schema.json",
+	"extends": ["../../../common/build/build-common/tsdoc-base.json"]
+}