@fluidframework/tree 2.41.0-338401 → 2.41.0

package/src/simple-tree/node-kinds/object/index.ts

@@ -0,0 +1,17 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export {
+	createUnknownOptionalFieldPolicy,
+	type FieldHasDefault,
+	type InsertableObjectFromAnnotatedSchemaRecord,
+	type InsertableObjectFromSchemaRecord,
+	lazilyAllocateIdentifier,
+	type ObjectFromSchemaRecord,
+	objectSchema,
+	setField,
+	type TreeObjectNode,
+} from "./objectNode.js";
+export { isObjectNodeSchema, ObjectNodeSchema } from "./objectNodeTypes.js";

package/src/simple-tree/{objectNode.ts → node-kinds/object/objectNode.ts}

@@ -5,33 +5,19 @@
 
 import { assert, Lazy, fail, debugAssert } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
+import { createIdCompressor } from "@fluidframework/id-compressor/internal";
 
-import type { FieldKey, SchemaPolicy } from "../core/index.js";
+import type { FieldKey, SchemaPolicy } from "../../../core/index.js";
 import {
 	FieldKinds,
 	type FlexTreeField,
 	type FlexTreeNode,
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
-} from "../feature-libraries/index.js";
-import { getTreeNodeForField } from "./getTreeNodeForField.js";
-import {
-	type ImplicitFieldSchema,
-	getStoredKey,
-	getExplicitStoredKey,
-	type TreeFieldFromImplicitField,
-	type InsertableTreeFieldFromImplicitField,
-	type FieldSchema,
-	normalizeFieldSchema,
-	type ImplicitAllowedTypes,
-	FieldKind,
-	type NodeSchemaMetadata,
-	type FieldSchemaAlpha,
-	ObjectFieldSchema,
-	type ImplicitAnnotatedFieldSchema,
-	unannotateSchemaRecord,
-	type UnannotateSchemaRecord,
-} from "./schemaTypes.js";
+} from "../../../feature-libraries/index.js";
+import { type RestrictiveStringRecord, type FlattenKeys, brand } from "../../../util/index.js";
+
 import {
 	type TreeNodeSchema,
 	NodeKind,
@@ -44,18 +30,36 @@ import {
 	type Context,
 	UnhydratedFlexTreeNode,
 	getOrCreateInnerNode,
-} from "./core/index.js";
-import { mapTreeFromNodeData, type InsertableContent } from "./toMapTree.js";
-import { prepareForInsertion } from "./prepareForInsertion.js";
-import type { RestrictiveStringRecord, FlattenKeys } from "../util/index.js";
+} from "../../core/index.js";
+import { getUnhydratedContext } from "../../createContext.js";
+import { getTreeNodeForField } from "../../getTreeNodeForField.js";
 import {
 	isObjectNodeSchema,
 	type ObjectNodeSchema,
 	type ObjectNodeSchemaInternalData,
 } from "./objectNodeTypes.js";
-import { TreeNodeValid, type MostDerivedData } from "./treeNodeValid.js";
-import { getUnhydratedContext } from "./createContext.js";
-import type { SimpleObjectFieldSchema } from "./simpleSchema.js";
+import { prepareForInsertion } from "../../prepareForInsertion.js";
+import {
+	type ImplicitFieldSchema,
+	getStoredKey,
+	getExplicitStoredKey,
+	type TreeFieldFromImplicitField,
+	type InsertableTreeFieldFromImplicitField,
+	type FieldSchema,
+	normalizeFieldSchema,
+	type ImplicitAllowedTypes,
+	FieldKind,
+	type NodeSchemaMetadata,
+	type FieldSchemaAlpha,
+	ObjectFieldSchema,
+	type ImplicitAnnotatedFieldSchema,
+	unannotateSchemaRecord,
+	type UnannotateSchemaRecord,
+} from "../../schemaTypes.js";
+import type { SimpleObjectFieldSchema } from "../../simpleSchema.js";
+import { mapTreeFromNodeData, type InsertableContent } from "../../toMapTree.js";
+import { TreeNodeValid, type MostDerivedData } from "../../treeNodeValid.js";
+import { stringSchema } from "../../leafNodeSchema.js";
 
 /**
  * Generates the properties for an ObjectNode from its field schema object.
@@ -197,6 +201,37 @@ function createFlexKeyMapping(fields: Record<string, ImplicitFieldSchema>): Simp
 	return keyMap;
 }
 
+const globalIdentifierAllocator: IIdCompressor = createIdCompressor();
+
+/**
+ * Modify `flexNode` to add a newly generated identifier under the given `storedKey`.
+ * @remarks
+ * This is used after checking if the user is trying to read an identifier field of an unhydrated node, but the identifier is not present.
+ * This means the identifier is an "auto-generated identifier", because otherwise it would have been supplied by the user at construction time and would have been successfully read just above.
+ * In this case, it is categorically impossible to provide an identifier (auto-generated identifiers can't be created until hydration/insertion time), so we emit an error.
+ * @privateRemarks
+ * TODO: this special case logic should move to the inner node (who's schema claims it has an identifier), rather than here, after we already read undefined out of a required field.
+ * TODO: unify this with a more general defaults mechanism.
+ */
+export function lazilyAllocateIdentifier(
+	flexNode: UnhydratedFlexTreeNode,
+	storedKey: FieldKey,
+): string {
+	debugAssert(() => !flexNode.mapTree.fields.has(storedKey) || "Identifier field already set");
+	const value = globalIdentifierAllocator.decompress(
+		globalIdentifierAllocator.generateCompressedId(),
+	);
+	flexNode.mapTree.fields.set(storedKey, [
+		{
+			type: brand(stringSchema.identifier),
+			value,
+			fields: new Map(),
+		},
+	]);
+
+	return value;
+}
+
 /**
  * Creates a proxy handler for the given schema.
  *
@@ -230,17 +265,11 @@ function createProxyHandler(
 					return getTreeNodeForField(field);
 				}
 
-				// TODO: this special case logic should move to the inner node (who's schema claims it has an identifier), rather than here, after we already read undefined out of a required field.
-				// Check if the user is trying to read an identifier field of an unhydrated node, but the identifier is not present.
-				// This means the identifier is an "auto-generated identifier", because otherwise it would have been supplied by the user at construction time and would have been successfully read just above.
-				// In this case, it is categorically impossible to provide an identifier (auto-generated identifiers can't be created until hydration/insertion time), so we emit an error.
 				if (
 					fieldInfo.schema.kind === FieldKind.Identifier &&
 					flexNode instanceof UnhydratedFlexTreeNode
 				) {
-					throw new UsageError(
-						"An automatically generated node identifier may not be queried until the node is inserted into the tree",
-					);
+					return lazilyAllocateIdentifier(flexNode, fieldInfo.storedKey);
 				}
 
 				return undefined;

package/src/simple-tree/{objectNodeTypes.ts → node-kinds/object/objectNodeTypes.ts}

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { RestrictiveStringRecord } from "../util/index.js";
+import type { RestrictiveStringRecord } from "../../../util/index.js";
 import type {
 	TreeObjectNode,
 	SimpleKeyMap,
@@ -13,10 +13,10 @@ import type {
 	FieldSchemaAlpha,
 	ImplicitAnnotatedFieldSchema,
 	UnannotateSchemaRecord,
-} from "./schemaTypes.js";
-import { NodeKind, type TreeNodeSchemaClass, type TreeNodeSchema } from "./core/index.js";
-import type { FieldKey } from "../core/index.js";
-import type { SimpleObjectFieldSchema, SimpleObjectNodeSchema } from "./simpleSchema.js";
+} from "../../schemaTypes.js";
+import { NodeKind, type TreeNodeSchemaClass, type TreeNodeSchema } from "../../core/index.js";
+import type { FieldKey } from "../../../core/index.js";
+import type { SimpleObjectFieldSchema, SimpleObjectNodeSchema } from "../../simpleSchema.js";
 
 /**
  * A schema for {@link TreeObjectNode}s.

package/src/simple-tree/prepareForInsertion.ts

@@ -118,7 +118,7 @@ export function prepareForInsertionContextless<TIn extends InsertableContent | u
 	const fieldSchema = convertField(normalizeFieldSchema(schema));
 	validateAndPrepare(schemaAndPolicy, hydratedData, fieldSchema, contentArray);
 
-	return mapTree as TIn extends undefined ? undefined : ExclusiveMapTree;
+	return mapTree;
 }
 
 /**

package/src/simple-tree/schemaTypes.ts

@@ -7,6 +7,7 @@ import type { ErasedType, IFluidHandle } from "@fluidframework/core-interfaces";
 import { Lazy } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
+import type { FieldKey } from "../core/index.js";
 import type { NodeIdentifierManager } from "../feature-libraries/index.js";
 import {
 	type MakeNominal,
@@ -20,6 +21,7 @@ import {
 	type RestrictiveStringRecord,
 	type IsUnion,
 } from "../util/index.js";
+
 import type {
 	Unhydrated,
 	NodeKind,
@@ -30,12 +32,11 @@ import type {
 	TreeNodeSchemaNonClass,
 } from "./core/index.js";
 import { inPrototypeChain } from "./core/index.js";
-import type { FieldKey } from "../core/index.js";
-import type { InsertableContent } from "./toMapTree.js";
 import { isLazy, type FlexListToUnion, type LazyItem } from "./flexList.js";
 import { LeafNodeSchema } from "./leafNodeSchema.js";
-import { TreeNodeValid } from "./treeNodeValid.js";
 import type { SimpleFieldSchema, SimpleObjectFieldSchema } from "./simpleSchema.js";
+import type { InsertableContent } from "./toMapTree.js";
+import { TreeNodeValid } from "./treeNodeValid.js";
 
 /**
  * Returns true if the given schema is a {@link TreeNodeSchemaClass}, or otherwise false if it is a {@link TreeNodeSchemaNonClass}.

package/src/simple-tree/simpleSchema.ts

@@ -4,6 +4,7 @@
  */
 
 import type { ValueSchema } from "../core/index.js";
+
 import type { NodeKind } from "./core/index.js";
 import type { FieldKind, FieldSchemaMetadata, NodeSchemaMetadata } from "./schemaTypes.js";
 

package/src/simple-tree/toMapTree.ts

@@ -46,7 +46,12 @@ import {
 	type Unhydrated,
 	UnhydratedFlexTreeNode,
 } from "./core/index.js";
-import { isObjectNodeSchema } from "./objectNodeTypes.js";
+// Required to prevent the introduction of new circular dependencies
+// TODO: Having the schema provide their own policy functions for compatibility which
+// toMapTree invokes instead of manually handling each kind would remove this bad
+// dependency, and reduce coupling.
+// eslint-disable-next-line import/no-internal-modules
+import { isObjectNodeSchema } from "./node-kinds/object/objectNodeTypes.js";
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
 
 /**
@@ -83,37 +88,13 @@ import type { IFluidHandle } from "@fluidframework/core-interfaces";
  * @param schemaValidationPolicy - The stored schema and policy to be used for validation, if the policy says schema
  * validation should happen. If it does, the input tree will be validated against this schema + policy, and an error will
  * be thrown if the tree does not conform to the schema. If undefined, no validation against the stored schema is done.
- *
- * TODO:BUG: AB#9131
- * This schema validation is done before defaults are provided.
- * This can not easily be fixed by reordering things within this implementation since even at the end of this function defaults requiring a context may not have been filled.
- * This means schema validation reject required fields getting their value from a default like identifier fields.
- *
  * @remarks The resulting tree will be populated with any defaults from {@link FieldProvider}s in the schema.
- *
- * @privateRemarks
- * TODO: AB#9126 AB#9131
- * When an app wants schema validation, we should ensure data is validated. Doing the validation here is not robust (since many callers to this don't have a context and thus can't opt into validation).
- * Additionally the validation here does not correctly handle default values, and introduces a second schema representation which is a bit odd API wise as its typically derivable from the view schema.
- * It may make more sense to validate when hydrating the MapTreeNode when the context is known and the defaults are available.
- * Applying the "parse don't validate" idiom here could help ensuring we capture when the validation optionally happens in the type system to avoid missing or redundant validation,
- * as well as ensuring validation happens after defaulting (or can handle validating data missing defaults)
  */
-export function mapTreeFromNodeData(
-	data: InsertableContent,
-	allowedTypes: ImplicitAllowedTypes,
-	context?: NodeIdentifierManager,
-): ExclusiveMapTree;
-export function mapTreeFromNodeData(
-	data: InsertableContent | undefined,
-	allowedTypes: ImplicitFieldSchema,
-	context?: NodeIdentifierManager,
-): ExclusiveMapTree | undefined;
-export function mapTreeFromNodeData(
-	data: InsertableContent | undefined,
+export function mapTreeFromNodeData<TIn extends InsertableContent | undefined>(
+	data: TIn,
 	allowedTypes: ImplicitFieldSchema,
 	context?: NodeIdentifierManager,
-): ExclusiveMapTree | undefined {
+): TIn extends undefined ? undefined : ExclusiveMapTree {
 	const normalizedFieldSchema = normalizeFieldSchema(allowedTypes);
 
 	if (data === undefined) {
@@ -121,14 +102,14 @@ export function mapTreeFromNodeData(
 		if (normalizedFieldSchema.kind !== FieldKind.Optional) {
 			throw new UsageError("Got undefined for non-optional field.");
 		}
-		return undefined;
+		return undefined as TIn extends undefined ? undefined : ExclusiveMapTree;
 	}
 
 	const mapTree = nodeDataToMapTree(data, normalizedFieldSchema.allowedTypeSet);
 	// Add what defaults can be provided. If no `context` is providing, some defaults may still be missing.
 	addDefaultsToMapTree(mapTree, normalizedFieldSchema.allowedTypes, context);
 
-	return mapTree;
+	return mapTree as TIn extends undefined ? undefined : ExclusiveMapTree;
 }
 
 /**

package/src/simple-tree/toStoredSchema.ts

@@ -21,16 +21,17 @@ import {
 } from "../core/index.js";
 import { FieldKinds, type FlexFieldKind } from "../feature-libraries/index.js";
 import { brand, getOrCreate } from "../util/index.js";
+
 import { NodeKind } from "./core/index.js";
-import { FieldKind, normalizeFieldSchema, type ImplicitFieldSchema } from "./schemaTypes.js";
-import { walkFieldSchema } from "./walkFieldSchema.js";
 import { LeafNodeSchema } from "./leafNodeSchema.js";
+import { FieldKind, normalizeFieldSchema, type ImplicitFieldSchema } from "./schemaTypes.js";
 import type {
 	SimpleFieldSchema,
 	SimpleNodeSchema,
 	SimpleNodeSchemaBase,
 	SimpleTreeSchema,
 } from "./simpleSchema.js";
+import { walkFieldSchema } from "./walkFieldSchema.js";
 
 const viewToStoredCache = new WeakMap<ImplicitFieldSchema, TreeStoredSchema>();
 

package/src/simple-tree/treeNodeValid.ts

@@ -4,6 +4,9 @@
  */
 
 import { assert, fail } from "@fluidframework/core-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
+import { type FlexTreeNode, isFlexTreeNode } from "../feature-libraries/index.js";
 
 import {
 	type TreeNodeSchema,
@@ -18,9 +21,6 @@ import {
 	type Context,
 	type UnhydratedFlexTreeNode,
 } from "./core/index.js";
-import { type FlexTreeNode, isFlexTreeNode } from "../feature-libraries/index.js";
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
-
 import { getSimpleNodeSchemaFromInnerNode } from "./core/index.js";
 import { markEager } from "./flexList.js";
 

package/src/simple-tree/walkFieldSchema.ts

@@ -4,7 +4,6 @@
  */
 
 import { type TreeNodeSchema, walkAllowedTypes, type SchemaVisitor } from "./core/index.js";
-
 import { type ImplicitFieldSchema, normalizeFieldSchema } from "./schemaTypes.js";
 
 /**

package/src/treeFactory.ts

@@ -98,7 +98,7 @@ export const SharedTree = configuredSharedTree({});
  * 	// eslint-disable-next-line import/no-internal-modules
  * } from "@fluidframework/tree/internal";
  * const SharedTree = configuredSharedTree({
- * 	forest: ForestType.Reference,
+ * 	forest: ForestTypeReference,
  * 	jsonValidator: typeboxValidator,
  * 	treeEncodeType: TreeCompressionStrategy.Uncompressed,
  * });

package/src/util/bTreeUtils.ts

@@ -4,6 +4,7 @@
  */
 
 import { BTree } from "@tylerbu/sorted-btree-es6";
+
 import { brand, type Brand } from "./brand.js";
 
 export type TupleBTree<K, V> = Brand<BTree<K, V>, "TupleBTree">;

package/src/util/breakable.ts

@@ -8,14 +8,24 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 /**
  * An object which can enter a "broken" state where trying to use it is a UsageError.
+ * @remarks
+ * Use {@link WithBreakable} to apply this to another object.
+ * @sealed
  */
 export class Breakable {
 	private brokenBy?: Error;
 
-	public constructor(private readonly name: string) {}
+	public constructor(
+		/**
+		 * A name for a given breakable scope.
+		 * @remarks
+		 * This is useful for documenting the semantics of a given Breakable and when inspecting things in the debugger, but is currently otherwise unused.
+		 */
+		private readonly name: string,
+	) {}
 
 	/**
-	 * Throws if the object is in the broken state.
+	 * Throws if this object is in the broken state.
 	 * @remarks
 	 * Can use {@link throwIfBroken} to apply this to a method.
 	 */
@@ -47,7 +57,7 @@ export class Breakable {
 	 * @privateRemarks
 	 * If there is a use-case, this should be made public.
 	 */
-	public rethrowCaught(brokenBy: unknown): never {
+	private rethrowCaught(brokenBy: unknown): never {
 		if (brokenBy instanceof Error) {
 			this.break(brokenBy);
 		}
@@ -59,7 +69,7 @@ export class Breakable {
 	/**
 	 * Runs code which should break the object if it throws.
 	 * @remarks
-	 * This also throws if already broken like {@link Breakable.use}.
+	 * Like {@link Breakable.use}, this also throws if already broken.
 	 * Any exceptions this catches are re-thrown.
 	 * Can use {@link breakingMethod} to apply this to a method.
 	 */
@@ -90,6 +100,11 @@ export class Breakable {
  * See decorators {@link breakingMethod} and {@link throwIfBroken} for ease of use.
  */
 export interface WithBreakable {
+	/**
+	 * The breaker for this object.
+	 * @remarks
+	 * If this `breaker` is in the broken state, the `WithBreakable` should be considered in a broken state.
+	 */
 	readonly breaker: Breakable;
 }
 

package/dist/simple-tree/api/testRecursiveDomain.d.ts

@@ -1,62 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { FieldKind } from "../schemaTypes.js";
-import type { NodeKind } from "../core/index.js";
-/**
- * To make API-Extractor happy, the base type has to be exported in addition to the actual schema class.
- * Ideally this would be inlined into the class definition below.
- *
- * TODO:
- * Fix API-Extractor to support class based schema, and remove this workaround (inline this type into `RecursiveObject extends` below).
- * Error: src/class-tree/testRecursiveDomain.ts:32:1 - (ae-forgotten-export) The symbol "RecursiveObject_base" needs to be exported by the entry point index.d.ts
- * See https://github.com/microsoft/rushstack/issues/4429
- * @internal
- */
-export declare const base: import("../core/treeNodeSchema.js").TreeNodeSchemaClass<"Test Recursive Domain.testObject", NodeKind.Object, import("./typesUnsafe.js").System_Unsafe.TreeObjectNodeUnsafe<{
-    readonly recursive: import("./typesUnsafe.js").System_Unsafe.FieldSchemaUnsafe<FieldKind.Optional, readonly [() => typeof RecursiveObject], unknown>;
-    readonly number: import("../leafNodeSchema.js").LeafSchema<"number", number>;
-}, "Test Recursive Domain.testObject">, object & {
-    readonly number: number;
-} & {
-    readonly recursive?: RecursiveObject | undefined;
-}, false, {
-    readonly recursive: import("./typesUnsafe.js").System_Unsafe.FieldSchemaUnsafe<FieldKind.Optional, readonly [() => typeof RecursiveObject], unknown>;
-    readonly number: import("../leafNodeSchema.js").LeafSchema<"number", number>;
-}>;
-/**
- * @internal
- */
-export declare class RecursiveObject extends base {
-}
-/**
- * Due to https://github.com/microsoft/TypeScript/issues/55832 this is expected to compile to a d.ts file which contain `any`, and therefore the other (above) approach using class definitions is recommended for recursive schema.
- * See {@link SchemaFactory} for documentation covering this detail.
- * @internal
- */
-export declare const RecursiveObjectPojoMode: import("../core/treeNodeSchema.js").TreeNodeSchemaClass<"Test Recursive Domain.testPOJOObject", NodeKind.Object, import("./typesUnsafe.js").System_Unsafe.TreeObjectNodeUnsafe<{
-    readonly recursive: import("./typesUnsafe.js").System_Unsafe.FieldSchemaUnsafe<FieldKind.Optional, readonly [() => import("../core/treeNodeSchema.js").TreeNodeSchemaClass<"Test Recursive Domain.testPOJOObject", NodeKind.Object, import("./typesUnsafe.js").System_Unsafe.TreeObjectNodeUnsafe<any, "Test Recursive Domain.testPOJOObject">, object & {
-        readonly number: number;
-    } & {
-        readonly recursive?: import("./typesUnsafe.js").System_Unsafe.TreeObjectNodeUnsafe<any, "Test Recursive Domain.testPOJOObject"> | undefined;
-    }, false, any>], unknown>;
-    readonly number: import("../leafNodeSchema.js").LeafSchema<"number", number>;
-}, "Test Recursive Domain.testPOJOObject">, object & {
-    readonly number: number;
-} & {
-    readonly recursive?: import("./typesUnsafe.js").System_Unsafe.TreeObjectNodeUnsafe<{
-        readonly recursive: import("./typesUnsafe.js").System_Unsafe.FieldSchemaUnsafe<FieldKind.Optional, readonly [() => import("../core/treeNodeSchema.js").TreeNodeSchemaClass<"Test Recursive Domain.testPOJOObject", NodeKind.Object, import("./typesUnsafe.js").System_Unsafe.TreeObjectNodeUnsafe<any, "Test Recursive Domain.testPOJOObject">, object & {
-            readonly number: number;
-        } & any, false, any>], unknown>;
-        readonly number: import("../leafNodeSchema.js").LeafSchema<"number", number>;
-    }, "Test Recursive Domain.testPOJOObject"> | undefined;
-}, false, {
-    readonly recursive: import("./typesUnsafe.js").System_Unsafe.FieldSchemaUnsafe<FieldKind.Optional, readonly [() => import("../core/treeNodeSchema.js").TreeNodeSchemaClass<"Test Recursive Domain.testPOJOObject", NodeKind.Object, import("./typesUnsafe.js").System_Unsafe.TreeObjectNodeUnsafe<any, "Test Recursive Domain.testPOJOObject">, object & {
-        readonly number: number;
-    } & {
-        readonly recursive?: import("./typesUnsafe.js").System_Unsafe.TreeObjectNodeUnsafe<any, "Test Recursive Domain.testPOJOObject"> | undefined;
-    }, false, any>], unknown>;
-    readonly number: import("../leafNodeSchema.js").LeafSchema<"number", number>;
-}>;
-//# sourceMappingURL=testRecursiveDomain.d.ts.map

package/dist/simple-tree/api/testRecursiveDomain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"testRecursiveDomain.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/testRecursiveDomain.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAeH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAIjD;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;EAGf,CAAC;AAEH;;GAEG;AACH,qBAAa,eAAgB,SAAQ,IAAI;CAAG;AAE5C;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;EAGlC,CAAC"}

package/dist/simple-tree/api/testRecursiveDomain.js

@@ -1,45 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RecursiveObjectPojoMode = exports.RecursiveObject = exports.base = void 0;
-/**
- * This file exists and is package exported to aid in testing of exporting recursive types across package boundaries.
- * Sometimes when TypeScript generates d.ts files, they type check significantly differently than the original source (One example of this: https://github.com/microsoft/TypeScript/issues/20979).
- * Unfortunately our recursive schema types are an example of types that have this kind of issue: the d.ts files tend to get "any" instead of the recursive type reference.
- * Currently we do not have tooling in place to test this in our test suite, and exporting these types here is a temporary crutch to aid in diagnosing this issue.
- */
-const schemaFactory_js_1 = require("./schemaFactory.js");
-const builder = new schemaFactory_js_1.SchemaFactory("Test Recursive Domain");
-/**
- * To make API-Extractor happy, the base type has to be exported in addition to the actual schema class.
- * Ideally this would be inlined into the class definition below.
- *
- * TODO:
- * Fix API-Extractor to support class based schema, and remove this workaround (inline this type into `RecursiveObject extends` below).
- * Error: src/class-tree/testRecursiveDomain.ts:32:1 - (ae-forgotten-export) The symbol "RecursiveObject_base" needs to be exported by the entry point index.d.ts
- * See https://github.com/microsoft/rushstack/issues/4429
- * @internal
- */
-exports.base = builder.objectRecursive("testObject", {
-    recursive: builder.optionalRecursive([() => RecursiveObject]),
-    number: builder.number,
-});
-/**
- * @internal
- */
-class RecursiveObject extends exports.base {
-}
-exports.RecursiveObject = RecursiveObject;
-/**
- * Due to https://github.com/microsoft/TypeScript/issues/55832 this is expected to compile to a d.ts file which contain `any`, and therefore the other (above) approach using class definitions is recommended for recursive schema.
- * See {@link SchemaFactory} for documentation covering this detail.
- * @internal
- */
-exports.RecursiveObjectPojoMode = builder.objectRecursive("testPOJOObject", {
-    recursive: builder.optionalRecursive([() => exports.RecursiveObjectPojoMode]),
-    number: builder.number,
-});
-//# sourceMappingURL=testRecursiveDomain.js.map

package/dist/simple-tree/api/testRecursiveDomain.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"testRecursiveDomain.js","sourceRoot":"","sources":["../../../src/simple-tree/api/testRecursiveDomain.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH;;;;;GAKG;AAEH,yDAAmD;AAUnD,MAAM,OAAO,GAAG,IAAI,gCAAa,CAAC,uBAAuB,CAAC,CAAC;AAE3D;;;;;;;;;GASG;AACU,QAAA,IAAI,GAAG,OAAO,CAAC,eAAe,CAAC,YAAY,EAAE;IACzD,SAAS,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC,GAAG,EAAE,CAAC,eAAe,CAAC,CAAC;IAC7D,MAAM,EAAE,OAAO,CAAC,MAAM;CACtB,CAAC,CAAC;AAEH;;GAEG;AACH,MAAa,eAAgB,SAAQ,YAAI;CAAG;AAA5C,0CAA4C;AAE5C;;;;GAIG;AACU,QAAA,uBAAuB,GAAG,OAAO,CAAC,eAAe,CAAC,gBAAgB,EAAE;IAChF,SAAS,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC,GAAG,EAAE,CAAC,+BAAuB,CAAC,CAAC;IACrE,MAAM,EAAE,OAAO,CAAC,MAAM;CACtB,CAAC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * This file exists and is package exported to aid in testing of exporting recursive types across package boundaries.\n * Sometimes when TypeScript generates d.ts files, they type check significantly differently than the original source (One example of this: https://github.com/microsoft/TypeScript/issues/20979).\n * Unfortunately our recursive schema types are an example of types that have this kind of issue: the d.ts files tend to get \"any\" instead of the recursive type reference.\n * Currently we do not have tooling in place to test this in our test suite, and exporting these types here is a temporary crutch to aid in diagnosing this issue.\n */\n\nimport { SchemaFactory } from \"./schemaFactory.js\";\n// This type is referred to by the base type generated by builder.object.\n// Adding the import of it here prevents TypeScript from generating inline includes for it in the d.ts file.\n// If we let TypeScript generate these includes, they use relative paths which break API extractor's rollup.\n// API-Extractor issue: https://github.com/microsoft/rushstack/issues/4507\n// eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports\nimport type { FieldKind } from \"../schemaTypes.js\";\n// eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports\nimport type { NodeKind } from \"../core/index.js\";\n\nconst builder = new SchemaFactory(\"Test Recursive Domain\");\n\n/**\n * To make API-Extractor happy, the base type has to be exported in addition to the actual schema class.\n * Ideally this would be inlined into the class definition below.\n *\n * TODO:\n * Fix API-Extractor to support class based schema, and remove this workaround (inline this type into `RecursiveObject extends` below).\n * Error: src/class-tree/testRecursiveDomain.ts:32:1 - (ae-forgotten-export) The symbol \"RecursiveObject_base\" needs to be exported by the entry point index.d.ts\n * See https://github.com/microsoft/rushstack/issues/4429\n * @internal\n */\nexport const base = builder.objectRecursive(\"testObject\", {\n\trecursive: builder.optionalRecursive([() => RecursiveObject]),\n\tnumber: builder.number,\n});\n\n/**\n * @internal\n */\nexport class RecursiveObject extends base {}\n\n/**\n * Due to https://github.com/microsoft/TypeScript/issues/55832 this is expected to compile to a d.ts file which contain `any`, and therefore the other (above) approach using class definitions is recommended for recursive schema.\n * See {@link SchemaFactory} for documentation covering this detail.\n * @internal\n */\nexport const RecursiveObjectPojoMode = builder.objectRecursive(\"testPOJOObject\", {\n\trecursive: builder.optionalRecursive([() => RecursiveObjectPojoMode]),\n\tnumber: builder.number,\n});\n"]}

package/dist/simple-tree/arrayNode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"arrayNode.d.ts","sourceRoot":"","sources":["../../src/simple-tree/arrayNode.ts"],"names":[],"mappings":"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"}