@fluidframework/tree 2.1.1 → 2.2.1

package/lib/feature-libraries/schema-aware/schemaAware.d.ts

@@ -1,76 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { TreeNodeSchemaIdentifier, TreeValue, ValueSchema, Multiplicity } from "../../core/index.js";
-import type { Assume, FlattenKeys, _InlineTrick } from "../../util/index.js";
-import type { ContextuallyTypedNodeData, typeNameSymbol, valueSymbol } from "../contextuallyTyped.js";
-import type { FlexAllowedTypes, FlexFieldNodeSchema, FlexFieldSchema, FlexListToUnion, FlexMapNodeSchema, FlexObjectNodeFields, FlexObjectNodeSchema, FlexTreeNodeSchema, LazyItem, LeafNodeSchema } from "../typed-schema/index.js";
-/**
- * Empty Object for use in type computations that should contribute no fields when `&`ed with another type.
- * @internal
- */
-export type EmptyObject = {};
-/**
- * Collects the various parts of the API together.
- * @internal
- */
-export type CollectOptions<TTypedFields, TValueSchema extends ValueSchema | undefined, TName> = TValueSchema extends undefined ? FlattenKeys<{
-    [typeNameSymbol]?: UnbrandedName<TName>;
-} & (TValueSchema extends ValueSchema ? {
-    [valueSymbol]: TreeValue<TValueSchema>;
-} : EmptyObject)> & TTypedFields : TValueSchema extends ValueSchema ? TreeValue<TValueSchema> : undefined;
-/**
- * Remove type brand from name.
- * @internal
- */
-export type UnbrandedName<TName> = [
-    TName extends TreeNodeSchemaIdentifier<infer S> ? S : string
-][_InlineTrick];
-/**
- * `{ [key: string]: FieldSchemaTypeInfo }` to `{ [key: string]: TypedTree }`
- *
- * In Editable mode, unwraps the fields.
- * @internal
- */
-export type TypedFields<TFields extends undefined | {
-    readonly [key: string]: FlexFieldSchema;
-}> = [
-    TFields extends {
-        [key: string]: FlexFieldSchema;
-    } ? {
-        -readonly [key in keyof TFields]: InsertableFlexField<TFields[key]>;
-    } : EmptyObject
-][_InlineTrick];
-/**
- * `TreeFieldSchema` to `TypedField`. May unwrap to child depending on FieldKind.
- * @internal
- */
-export type InsertableFlexField<TField extends FlexFieldSchema> = [
-    ApplyMultiplicity<TField["kind"]["multiplicity"], AllowedTypesToFlexInsertableTree<TField["allowedTypes"]>>
-][_InlineTrick];
-/**
- * Adjusts the API for a field based on its Multiplicity.
- * @internal
- */
-export type ApplyMultiplicity<TMultiplicity extends Multiplicity, TypedChild> = {
-    [Multiplicity.Forbidden]: undefined;
-    [Multiplicity.Optional]: undefined | TypedChild;
-    [Multiplicity.Sequence]: TypedChild[];
-    [Multiplicity.Single]: TypedChild;
-}[TMultiplicity];
-/**
- * Takes in `AllowedTypes` and returns a TypedTree union.
- * @internal
- */
-export type AllowedTypesToFlexInsertableTree<T extends FlexAllowedTypes> = [
-    T extends readonly LazyItem<FlexTreeNodeSchema>[] ? InsertableFlexNode<Assume<FlexListToUnion<T>, FlexTreeNodeSchema>> : ContextuallyTypedNodeData
-][_InlineTrick];
-/**
- * Generate a schema aware API for a single tree schema.
- * @internal
- */
-export type InsertableFlexNode<TSchema extends FlexTreeNodeSchema> = FlattenKeys<CollectOptions<TSchema extends FlexObjectNodeSchema<string, infer TFields extends FlexObjectNodeFields> ? TypedFields<TFields> : TSchema extends FlexFieldNodeSchema<string, infer TField extends FlexFieldSchema> ? InsertableFlexField<TField> : TSchema extends FlexMapNodeSchema<string, infer TField extends FlexFieldSchema> ? {
-    readonly [P in string]: InsertableFlexField<TField>;
-} : EmptyObject, TSchema extends LeafNodeSchema<string, infer TValueSchema extends ValueSchema> ? TValueSchema : undefined, TSchema["name"]>>;
-//# sourceMappingURL=schemaAware.d.ts.map

package/lib/feature-libraries/schema-aware/schemaAware.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemaAware.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/schema-aware/schemaAware.ts"],"names":[],"mappings":"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"}

package/lib/feature-libraries/schema-aware/schemaAware.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemaAware.js","sourceRoot":"","sources":["../../../src/feature-libraries/schema-aware/schemaAware.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type {\n\tTreeNodeSchemaIdentifier,\n\tTreeValue,\n\tValueSchema,\n\tMultiplicity,\n} from \"../../core/index.js\";\nimport type { Assume, FlattenKeys, _InlineTrick } from \"../../util/index.js\";\nimport type {\n\tContextuallyTypedNodeData,\n\ttypeNameSymbol,\n\tvalueSymbol,\n} from \"../contextuallyTyped.js\";\nimport type {\n\tFlexAllowedTypes,\n\tFlexFieldNodeSchema,\n\tFlexFieldSchema,\n\tFlexListToUnion,\n\tFlexMapNodeSchema,\n\tFlexObjectNodeFields,\n\tFlexObjectNodeSchema,\n\tFlexTreeNodeSchema,\n\tLazyItem,\n\tLeafNodeSchema,\n} from \"../typed-schema/index.js\";\n\n/**\n * Empty Object for use in type computations that should contribute no fields when `&`ed with another type.\n * @internal\n */\n// Using {} instead of interface {} or Record<string, never> for empty object here produces better IntelliSense in the generated types than `Record<string, never>` recommended by the linter.\n// Making this a type instead of an interface prevents it from showing up in IntelliSense, and also avoids breaking the typing somehow.\n// eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/consistent-type-definitions\nexport type EmptyObject = {};\n\n/**\n * Collects the various parts of the API together.\n * @internal\n */\nexport type CollectOptions<\n\tTTypedFields,\n\tTValueSchema extends ValueSchema | undefined,\n\tTName,\n> = TValueSchema extends undefined\n\t? FlattenKeys<\n\t\t\t{ [typeNameSymbol]?: UnbrandedName<TName> } & (TValueSchema extends ValueSchema\n\t\t\t\t? { [valueSymbol]: TreeValue<TValueSchema> }\n\t\t\t\t: EmptyObject)\n\t\t> &\n\t\t\tTTypedFields\n\t: TValueSchema extends ValueSchema\n\t\t? TreeValue<TValueSchema>\n\t\t: undefined;\n\n/**\n * Remove type brand from name.\n * @internal\n */\nexport type UnbrandedName<TName> = [\n\tTName extends TreeNodeSchemaIdentifier<infer S> ? S : string,\n][_InlineTrick];\n\n/**\n * `{ [key: string]: FieldSchemaTypeInfo }` to `{ [key: string]: TypedTree }`\n *\n * In Editable mode, unwraps the fields.\n * @internal\n */\nexport type TypedFields<\n\tTFields extends undefined | { readonly [key: string]: FlexFieldSchema },\n> = [\n\tTFields extends { [key: string]: FlexFieldSchema }\n\t\t? {\n\t\t\t\t-readonly [key in keyof TFields]: InsertableFlexField<TFields[key]>;\n\t\t\t}\n\t\t: EmptyObject,\n][_InlineTrick];\n\n/**\n * `TreeFieldSchema` to `TypedField`. May unwrap to child depending on FieldKind.\n * @internal\n */\nexport type InsertableFlexField<TField extends FlexFieldSchema> = [\n\tApplyMultiplicity<\n\t\tTField[\"kind\"][\"multiplicity\"],\n\t\tAllowedTypesToFlexInsertableTree<TField[\"allowedTypes\"]>\n\t>,\n][_InlineTrick];\n\n/**\n * Adjusts the API for a field based on its Multiplicity.\n * @internal\n */\nexport type ApplyMultiplicity<TMultiplicity extends Multiplicity, TypedChild> = {\n\t[Multiplicity.Forbidden]: undefined;\n\t[Multiplicity.Optional]: undefined | TypedChild;\n\t[Multiplicity.Sequence]: TypedChild[];\n\t[Multiplicity.Single]: TypedChild;\n}[TMultiplicity];\n\n/**\n * Takes in `AllowedTypes` and returns a TypedTree union.\n * @internal\n */\nexport type AllowedTypesToFlexInsertableTree<T extends FlexAllowedTypes> = [\n\tT extends readonly LazyItem<FlexTreeNodeSchema>[]\n\t\t? InsertableFlexNode<Assume<FlexListToUnion<T>, FlexTreeNodeSchema>>\n\t\t: ContextuallyTypedNodeData,\n][_InlineTrick];\n\n/**\n * Generate a schema aware API for a single tree schema.\n * @internal\n */\nexport type InsertableFlexNode<TSchema extends FlexTreeNodeSchema> = FlattenKeys<\n\tCollectOptions<\n\t\tTSchema extends FlexObjectNodeSchema<string, infer TFields extends FlexObjectNodeFields>\n\t\t\t? TypedFields<TFields>\n\t\t\t: TSchema extends FlexFieldNodeSchema<string, infer TField extends FlexFieldSchema>\n\t\t\t\t? InsertableFlexField<TField>\n\t\t\t\t: TSchema extends FlexMapNodeSchema<string, infer TField extends FlexFieldSchema>\n\t\t\t\t\t? {\n\t\t\t\t\t\t\treadonly [P in string]: InsertableFlexField<TField>;\n\t\t\t\t\t\t}\n\t\t\t\t\t: EmptyObject,\n\t\tTSchema extends LeafNodeSchema<string, infer TValueSchema extends ValueSchema>\n\t\t\t? TValueSchema\n\t\t\t: undefined,\n\t\tTSchema[\"name\"]\n\t>\n>;\n"]}

package/lib/simple-tree/nodeKeys.d.ts

@@ -1,41 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { LocalNodeKey, StableNodeKey } from "../feature-libraries/index.js";
-import type { TreeNode } from "./types.js";
-/**
- * A collection of utilities for managing {@link StableNodeKey}s.
- * A node key can be assigned to a node and allows that node to be easily retrieved from the tree at a later time. (see `nodeKey.map`).
- * @remarks {@link LocalNodeKey}s are put on {@link FlexTreeObjectNode}s via a special field.
- * A node with a node key in its schema must always have a node key.
- * TODO: A node key index leveraging this {@link NodeKeys} interface should be implemented for the simple tree layer.
- * @internal
- */
-export interface NodeKeys {
-    /**
-     * Create a new {@link LocalNodeKey} which can be used as the key for a node in the tree.
-     */
-    generate(): LocalNodeKey;
-    /**
-     * Convert the given {@link LocalNodeKey} into a UUID that can be serialized.
-     * @param key - the key to convert
-     */
-    stabilize(key: LocalNodeKey): StableNodeKey;
-    /**
-     * Convert a {@link StableNodeKey} back into its {@link LocalNodeKey} form.
-     * @param key - the key to convert
-     */
-    localize(key: StableNodeKey): LocalNodeKey;
-    /**
-     * Attempts to recompress a string key back into its {@link LocalNodeKey} form.
-     * @param key - The key to convert.
-     * @returns The {@link LocalNodeKey} associated with `key` or undefined if the key was not generated by any session known to this compressor.
-     */
-    tryLocalize(key: string): LocalNodeKey | undefined;
-    /**
-     * A map of all {@link LocalNodeKey}s in the document to their corresponding nodes.
-     */
-    readonly map: ReadonlyMap<LocalNodeKey, TreeNode>;
-}
-//# sourceMappingURL=nodeKeys.d.ts.map

package/lib/simple-tree/nodeKeys.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodeKeys.d.ts","sourceRoot":"","sources":["../../src/simple-tree/nodeKeys.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACjF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACxB;;OAEG;IACH,QAAQ,IAAI,YAAY,CAAC;IACzB;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,YAAY,GAAG,aAAa,CAAC;IAC5C;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,aAAa,GAAG,YAAY,CAAC;IAC3C;;;;OAIG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAAC;IACnD;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;CAClD"}

package/lib/simple-tree/nodeKeys.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodeKeys.js","sourceRoot":"","sources":["../../src/simple-tree/nodeKeys.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { LocalNodeKey, StableNodeKey } from \"../feature-libraries/index.js\";\nimport type { TreeNode } from \"./types.js\";\n\n/**\n * A collection of utilities for managing {@link StableNodeKey}s.\n * A node key can be assigned to a node and allows that node to be easily retrieved from the tree at a later time. (see `nodeKey.map`).\n * @remarks {@link LocalNodeKey}s are put on {@link FlexTreeObjectNode}s via a special field.\n * A node with a node key in its schema must always have a node key.\n * TODO: A node key index leveraging this {@link NodeKeys} interface should be implemented for the simple tree layer.\n * @internal\n */\nexport interface NodeKeys {\n\t/**\n\t * Create a new {@link LocalNodeKey} which can be used as the key for a node in the tree.\n\t */\n\tgenerate(): LocalNodeKey;\n\t/**\n\t * Convert the given {@link LocalNodeKey} into a UUID that can be serialized.\n\t * @param key - the key to convert\n\t */\n\tstabilize(key: LocalNodeKey): StableNodeKey;\n\t/**\n\t * Convert a {@link StableNodeKey} back into its {@link LocalNodeKey} form.\n\t * @param key - the key to convert\n\t */\n\tlocalize(key: StableNodeKey): LocalNodeKey;\n\t/**\n\t * Attempts to recompress a string key back into its {@link LocalNodeKey} form.\n\t * @param key - The key to convert.\n\t * @returns The {@link LocalNodeKey} associated with `key` or undefined if the key was not generated by any session known to this compressor.\n\t */\n\ttryLocalize(key: string): LocalNodeKey | undefined;\n\t/**\n\t * A map of all {@link LocalNodeKey}s in the document to their corresponding nodes.\n\t */\n\treadonly map: ReadonlyMap<LocalNodeKey, TreeNode>;\n}\n"]}

package/lib/simple-tree/schemaCaching.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemaCaching.d.ts","sourceRoot":"","sources":["../../src/simple-tree/schemaCaching.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EACX,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EACN,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EAEnB,MAAM,kBAAkB,CAAC;AAkB1B,wBAAgB,+BAA+B,CAC9C,MAAM,EAAE,cAAc,GACpB,kBAAkB,GAAG,SAAS,CAGhC;AAED,wBAAgB,4BAA4B,CAC3C,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,kBAAkB,GACtB,IAAI,CAON;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACrC,UAAU,EAAE,kBAAkB,GAC5B,cAAc,GAAG,SAAS,CAK5B;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,kBAAkB,GAAG,cAAc,CAElF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CACnC,UAAU,EAAE,eAAe,EAC3B,oBAAoB,EAAE,mBAAmB,GACvC,WAAW,CASb"}

package/lib/simple-tree/schemaCaching.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemaCaching.js","sourceRoot":"","sources":["../../src/simple-tree/schemaCaching.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAC;AAO7D,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,OAAO,EAIN,oBAAoB,GACpB,MAAM,kBAAkB,CAAC;AAE1B;;;GAGG;AACH,MAAM,gBAAgB,GAAkB,MAAM,CAAC,YAAY,CAAC,CAAC;AAE7D;;GAEG;AACH,MAAM,sBAAsB,GAAkB,MAAM,CAAC,kBAAkB,CAAC,CAAC;AAEzE;;GAEG;AACH,MAAM,uBAAuB,GAAkB,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAE3E,MAAM,UAAU,+BAA+B,CAC9C,MAAsB;IAEtB,8DAA8D;IAC9D,OAAQ,MAAc,CAAC,gBAAgB,CAAmC,CAAC;AAC5E,CAAC;AAED,MAAM,UAAU,4BAA4B,CAC3C,MAAsB,EACtB,IAAwB;IAExB,MAAM,CAAC,CAAC,CAAC,gBAAgB,IAAI,MAAM,CAAC,EAAE,KAAK,CAAC,kCAAkC,CAAC,CAAC;IAChF,MAAM,CAAC,CAAC,CAAC,sBAAsB,IAAI,IAAI,CAAC,EAAE,KAAK,CAAC,gCAAgC,CAAC,CAAC;IAClF,8DAA8D;IAC7D,MAAc,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC;IACzC,8DAA8D;IAC7D,IAAY,CAAC,sBAAsB,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CACrC,UAA8B;IAE9B,IAAI,sBAAsB,IAAI,UAAU,EAAE,CAAC;QAC1C,OAAO,UAAU,CAAC,sBAAsB,CAAmB,CAAC;IAC7D,CAAC;IACD,OAAO,SAAS,CAAC;AAClB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,UAA8B;IACjE,OAAO,sBAAsB,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,uBAAuB,CAAC,CAAC;AAC5E,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CACnC,UAA2B,EAC3B,oBAAyC;IAEzC,IAAI,uBAAuB,IAAI,UAAU,EAAE,CAAC;QAC3C,OAAO,UAAU,CAAC,uBAAuB,CAAgB,CAAC;IAC3D,CAAC;IAED,MAAM,WAAW,GAAG,oBAAoB,CAAC,oBAAoB,CAAC,CAAC;IAC/D,8DAA8D;IAC7D,UAAkB,CAAC,uBAAuB,CAAC,GAAG,WAAW,CAAC;IAC3D,OAAO,WAAW,CAAC;AACpB,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\n\nimport type {\n\tFlexFieldSchema,\n\tFlexTreeNodeSchema,\n\tTreeNodeSchemaBase,\n} from \"../feature-libraries/index.js\";\nimport { fail } from \"../util/index.js\";\n\nimport {\n\ttype FieldSchema,\n\ttype ImplicitFieldSchema,\n\ttype TreeNodeSchema,\n\tnormalizeFieldSchema,\n} from \"./schemaTypes.js\";\n\n/**\n * A symbol for storing FlexTreeSchema on TreeNodeSchema.\n * Eagerly set on leaves, and lazily set for other cases.\n */\nconst flexSchemaSymbol: unique symbol = Symbol(`flexSchema`);\n\n/**\n * A symbol for storing TreeNodeSchema on FlexTreeNode's schema.\n */\nconst simpleNodeSchemaSymbol: unique symbol = Symbol(`simpleNodeSchema`);\n\n/**\n * A symbol for storing {@link FieldSchema}s on a {@link FlexFieldSchema}.\n */\nconst simpleFieldSchemaSymbol: unique symbol = Symbol(`simpleFieldSchema`);\n\nexport function cachedFlexSchemaFromClassSchema(\n\tschema: TreeNodeSchema,\n): TreeNodeSchemaBase | undefined {\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\treturn (schema as any)[flexSchemaSymbol] as TreeNodeSchemaBase | undefined;\n}\n\nexport function setFlexSchemaFromClassSchema(\n\tsimple: TreeNodeSchema,\n\tflex: TreeNodeSchemaBase,\n): void {\n\tassert(!(flexSchemaSymbol in simple), 0x91f /* simple schema already marked */);\n\tassert(!(simpleNodeSchemaSymbol in flex), 0x920 /* flex schema already marked */);\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t(simple as any)[flexSchemaSymbol] = flex;\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t(flex as any)[simpleNodeSchemaSymbol] = simple;\n}\n\n/**\n * Gets the {@link TreeNodeSchema} cached on the provided {@link FlexTreeNodeSchema | flexSchema}.\n * Returns `undefined` if no cached value is found.\n */\nexport function tryGetSimpleNodeSchema(\n\tflexSchema: FlexTreeNodeSchema,\n): TreeNodeSchema | undefined {\n\tif (simpleNodeSchemaSymbol in flexSchema) {\n\t\treturn flexSchema[simpleNodeSchemaSymbol] as TreeNodeSchema;\n\t}\n\treturn undefined;\n}\n\n/**\n * Gets the {@link TreeNodeSchema} cached on the provided {@link FlexTreeNodeSchema | flexSchema}.\n * Fails if no cached value is found.\n */\nexport function getSimpleNodeSchema(flexSchema: FlexTreeNodeSchema): TreeNodeSchema {\n\treturn tryGetSimpleNodeSchema(flexSchema) ?? fail(\"missing simple schema\");\n}\n\n/**\n * Gets the {@link FieldSchema} which corresponds with the provided {@link FlexFieldSchema | flexSchema}.\n * Caches the result on the provided `flexSchema` for future access.\n * @param flexSchema - The flex schema on which the result will be cached.\n * @param implicitSimpleSchema - The allowed types from which the `FieldSchema` will be derived.\n */\nexport function getSimpleFieldSchema(\n\tflexSchema: FlexFieldSchema,\n\timplicitSimpleSchema: ImplicitFieldSchema,\n): FieldSchema {\n\tif (simpleFieldSchemaSymbol in flexSchema) {\n\t\treturn flexSchema[simpleFieldSchemaSymbol] as FieldSchema;\n\t}\n\n\tconst fieldSchema = normalizeFieldSchema(implicitSimpleSchema);\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t(flexSchema as any)[simpleFieldSchemaSymbol] = fieldSchema;\n\treturn fieldSchema;\n}\n"]}

package/lib/simple-tree/schemaCreationUtilities.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemaCreationUtilities.d.ts","sourceRoot":"","sources":["../../src/simple-tree/schemaCreationUtilities.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAGjE,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC1E,OAAO,KAAK,EAAkB,QAAQ,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACtF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAEX,sBAAsB,EACtB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;GAMG;AAGH,wBAAgB,eAAe,CAAC,MAAM,SAAS,MAAM,EAAE,KAAK,SAAS,MAAM,GAAG,MAAM,EACnF,OAAO,EAAE,aAAa,CAAC,MAAM,EAAE,KAAK,CAAC,EACrC,IAAI,EAAE,KAAK;oBAa8C,KAAK;;oBAAL,KAAK;GAiB9D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,wBAAgB,SAAS,CAAC,MAAM,SAAS,MAAM,EAAE,KAAK,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1F,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,EAC9B,OAAO,EAAE,KAAK,+CAmBoC,MAAM;;;;;;MAgBxD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,SAAS,MAAM,EAAE,OAAO,EAC7D,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAC3B,OAAO,EAAE,CAEX;AAED;;;;;;;;;;;;;;;;;;GAkBG;AAEH,wBAAgB,eAAe,CAAC,MAAM,SAAS,MAAM,EAAE,KAAK,CAAC,OAAO,SAAS,MAAM,EAClF,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,EAC9B,OAAO,EAAE,SAAS,OAAO,EAAE,oCASwB,MAAM;;;;;;IAgBzD"}

package/lib/simple-tree/schemaCreationUtilities.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemaCreationUtilities.js","sourceRoot":"","sources":["../../src/simple-tree/schemaCreationUtilities.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport type { EmptyObject } from \"../feature-libraries/index.js\";\nimport { fail } from \"../util/index.js\";\n\nimport type { SchemaFactory, ScopedSchemaName } from \"./schemaFactory.js\";\nimport type { NodeFromSchema, NodeKind, TreeNodeSchemaClass } from \"./schemaTypes.js\";\nimport type { TreeNode } from \"./types.js\";\nimport type {\n\tInsertableObjectFromSchemaRecord,\n\tObjectFromSchemaRecord,\n} from \"./objectNode.js\";\n\n/**\n * Create a schema for a node with no state.\n * @remarks\n * This is commonly used in unions when the only information needed is which kind of node the value is.\n * Enums are a common example of this pattern.\n * @internal\n */\n// Return type is intentionally derived.\n// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\nexport function singletonSchema<TScope extends string, TName extends string | number>(\n\tfactory: SchemaFactory<TScope, TName>,\n\tname: TName,\n) {\n\tclass SingletonSchema extends factory.object(name, {}) {\n\t\tpublic constructor(data?: EmptyObject) {\n\t\t\tsuper(data ?? {});\n\t\t}\n\t\tpublic get value(): TName {\n\t\t\treturn name;\n\t\t}\n\t}\n\n\ttype NodeType = object &\n\t\tTreeNode &\n\t\tObjectFromSchemaRecord<EmptyObject> & { readonly value: TName };\n\n\t// Returning SingletonSchema without a type conversion results in TypeScript generating something like `readonly \"__#124291@#brand\": unknown;`\n\t// for the private brand field of TreeNode.\n\t// This numeric id doesn't seem to be stable over incremental builds, and thus causes diffs in the API extractor reports.\n\t// This is avoided by doing this type conversion.\n\t// The conversion is done via assignment instead of `as` to get stronger type safety.\n\tconst toReturn: TreeNodeSchemaClass<\n\t\tScopedSchemaName<TScope, TName>,\n\t\tNodeKind.Object,\n\t\tNodeType,\n\t\tobject & InsertableObjectFromSchemaRecord<EmptyObject>,\n\t\ttrue\n\t> &\n\t\t(new () => NodeType) = SingletonSchema;\n\n\treturn toReturn;\n}\n\n/**\n * Converts an enum into a collection of schema which can be used in a union.\n * @remarks\n * Currently only supports `string` enums.\n * @example\n * ```typescript\n * enum Mode {\n * \ta = \"A\",\n * \tb = \"B\",\n * }\n * const ModeNodes = adaptEnum(schema, Mode);\n * type ModeNodes = NodeFromSchema<(typeof ModeNodes)[keyof typeof ModeNodes]>;\n * const nodeFromString: ModeNodes = ModeNodes(Mode.a);\n * const nodeFromSchema: ModeNodes = new ModeNodes.a();\n * const nameFromNode: Mode = nodeFromSchema.value;\n * class Parent extends schemaFactory.object(\"Parent\", {\n * \tmode: typedObjectValues(ModeNodes),\n * }) {}\n * ```\n * @privateRemarks\n * TODO:\n * Extends this to support numeric enums.\n * Maybe require an explicit nested scope to group them under, or at least a warning about collisions.\n * Maybe just provide `SchemaFactory.nested` to east creating nested scopes?\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\nexport function adaptEnum<TScope extends string, const TEnum extends Record<string, string>>(\n\tfactory: SchemaFactory<TScope>,\n\tmembers: TEnum,\n) {\n\ttype Values = TEnum[keyof TEnum];\n\tconst values = Object.values(members) as Values[];\n\tconst inverse = new Map(Object.entries(members).map(([key, value]) => [value, key])) as Map<\n\t\tValues,\n\t\tkeyof TEnum\n\t>;\n\n\tif (inverse.size !== values.length) {\n\t\tthrow new UsageError(\"All members of enums must have distinct values.\");\n\t}\n\n\ttype TOut = {\n\t\treadonly [Property in keyof TEnum]: ReturnType<\n\t\t\ttypeof singletonSchema<TScope, TEnum[Property]>\n\t\t>;\n\t};\n\t// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\n\tconst factoryOut = <TValue extends Values>(value: TValue) => {\n\t\treturn new out[inverse.get(value) ?? fail(\"missing enum value\")]({}) as NodeFromSchema<\n\t\t\tReturnType<typeof singletonSchema<TScope, TValue>>\n\t\t>;\n\t};\n\tconst out = factoryOut as typeof factoryOut & TOut;\n\tfor (const [key, value] of Object.entries(members)) {\n\t\tObject.defineProperty(out, key, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: false,\n\t\t\twritable: false,\n\t\t\tvalue: singletonSchema(factory, value),\n\t\t});\n\t}\n\n\treturn out;\n}\n\n/**\n * `Object.values`, but with more specific types.\n * @internal\n */\nexport function typedObjectValues<TKey extends string, TValues>(\n\tobject: Record<TKey, TValues>,\n): TValues[] {\n\treturn Object.values(object);\n}\n\n/**\n * Converts an array of distinct strings into a collection of schema which can be used like an enum style union.\n * @remarks\n * The returned collection is also a function which can be used to convert strings into {@link Unhydrated} nodes in the union.\n * Each node type has a `.value` getter which returns the associated string.\n *\n * The produced nodes use the provided strings as their `name`, and don't store any data beyond that.\n * @example\n * ```typescript\n * const Mode = enumFromStrings(schemaFactory, [\"Fun\", \"Cool\"]);\n * type Mode = NodeFromSchema<(typeof Mode)[keyof typeof Mode]>;\n * const nodeFromString: Mode = Mode(\"Fun\");\n * const nodeFromSchema: Mode = new Mode.Fun();\n * const nameFromNode = nodeFromSchema.value;\n *\n * class Parent extends schemaFactory.object(\"Parent\", { mode: typedObjectValues(Mode) }) {}\n * ```\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\nexport function enumFromStrings<TScope extends string, const Members extends string>(\n\tfactory: SchemaFactory<TScope>,\n\tmembers: readonly Members[],\n) {\n\tconst names = new Set(members);\n\tif (names.size !== members.length) {\n\t\tthrow new UsageError(\"All members of enums must have distinct names\");\n\t}\n\n\ttype TOut = Record<Members, ReturnType<typeof singletonSchema<TScope, Members>>>;\n\t// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\n\tconst factoryOut = <TValue extends Members>(value: TValue) => {\n\t\treturn new out[value]({}) as NodeFromSchema<\n\t\t\tReturnType<typeof singletonSchema<TScope, TValue>>\n\t\t>;\n\t};\n\tconst out = factoryOut as typeof factoryOut & TOut;\n\tfor (const name of members) {\n\t\tObject.defineProperty(out, name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: false,\n\t\t\twritable: false,\n\t\t\tvalue: singletonSchema(factory, name),\n\t\t});\n\t}\n\n\treturn out;\n}\n\n// TODO: Why does this one generate an invalid d.ts file if exported?\n// Tracked by https://github.com/microsoft/TypeScript/issues/58688\n// TODO: replace enumFromStrings above with this simpler implementation when the TypeScript bug is resolved.\n// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\nfunction _enumFromStrings2<TScope extends string, const Members extends readonly string[]>(\n\tfactory: SchemaFactory<TScope>,\n\tmembers: Members,\n) {\n\tconst enumObject: {\n\t\t[key in keyof Members as Members[key] extends string\n\t\t\t? Members[key]\n\t\t\t: string]: Members[key] extends string ? Members[key] : string;\n\t} = Object.create(null);\n\tfor (const name of members) {\n\t\tObject.defineProperty(enumObject, name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: false,\n\t\t\twritable: false,\n\t\t\tvalue: name,\n\t\t});\n\t}\n\n\treturn adaptEnum(factory, enumObject);\n}\n"]}

package/lib/simple-tree/schemaFactory.d.ts.map

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

package/lib/simple-tree/schemaFactory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemaFactory.js","sourceRoot":"","sources":["../../src/simple-tree/schemaFactory.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert, unreachableCase } from \"@fluidframework/core-utils/internal\";\n// Include this unused import to avoid TypeScript generating an inline import for IFluidHandle in the d.ts file\n// which degrades the API-Extractor report quality since API-Extractor can not tell the inline import is the same as the non-inline one.\n// eslint-disable-next-line unused-imports/no-unused-imports\nimport type { IFluidHandle as _dummyImport } from \"@fluidframework/core-interfaces\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\nimport { isFluidHandle } from \"@fluidframework/runtime-utils/internal\";\n\nimport type { TreeValue } from \"../core/index.js\";\nimport { type NodeKeyManager, type Unenforced, isLazy } from \"../feature-libraries/index.js\";\nimport {\n\ttype RestrictiveReadonlyRecord,\n\tgetOrCreate,\n\tisReadonlyArray,\n} from \"../util/index.js\";\n\nimport {\n\tbooleanSchema,\n\thandleSchema,\n\tLeafNodeSchema,\n\tnullSchema,\n\tnumberSchema,\n\tstringSchema,\n} from \"./leafNodeSchema.js\";\nimport {\n\tFieldKind,\n\ttype FieldSchema,\n\ttype ImplicitAllowedTypes,\n\ttype ImplicitFieldSchema,\n\ttype InsertableTreeNodeFromImplicitAllowedTypes,\n\ttype NodeKind,\n\ttype TreeNodeSchema,\n\ttype TreeNodeSchemaClass,\n\ttype WithType,\n\ttype FieldProps,\n\tcreateFieldSchema,\n\ttype DefaultProvider,\n\tgetDefaultProvider,\n} from \"./schemaTypes.js\";\nimport { type TreeArrayNode, arraySchema } from \"./arrayNode.js\";\nimport {\n\ttype InsertableObjectFromSchemaRecord,\n\ttype TreeObjectNode,\n\tobjectSchema,\n} from \"./objectNode.js\";\nimport { type TreeMapNode, mapSchema } from \"./mapNode.js\";\nimport type {\n\tFieldSchemaUnsafe,\n\t// Adding these unused imports makes the generated d.ts file produced by TypeScript stop breaking API-Extractor's rollup generation.\n\t// Without this import, TypeScript generates inline `import(\"../..\")` statements in the d.ts file,\n\t// which API-Extractor leaves as is when generating the rollup, leaving them pointing at the wrong directory.\n\t// API-Extractor issue: https://github.com/microsoft/rushstack/issues/4507\n\t// eslint-disable-next-line unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars\n\tFieldHasDefaultUnsafe,\n\t// eslint-disable-next-line unused-imports/no-unused-imports, @typescript-eslint/no-unused-vars\n\tInsertableTreeFieldFromImplicitFieldUnsafe,\n\tInsertableObjectFromSchemaRecordUnsafe,\n\tInsertableTreeNodeFromImplicitAllowedTypesUnsafe,\n\tTreeArrayNodeUnsafe,\n\tTreeMapNodeUnsafe,\n\tTreeObjectNodeUnsafe,\n} from \"./typesUnsafe.js\";\nimport { createFieldSchemaUnsafe } from \"./schemaFactoryRecursive.js\";\nimport { inPrototypeChain, TreeNodeValid } from \"./types.js\";\n/**\n * Gets the leaf domain schema compatible with a given {@link TreeValue}.\n */\nexport function schemaFromValue(value: TreeValue): TreeNodeSchema {\n\tswitch (typeof value) {\n\t\tcase \"boolean\":\n\t\t\treturn booleanSchema;\n\t\tcase \"number\":\n\t\t\treturn numberSchema;\n\t\tcase \"string\":\n\t\t\treturn stringSchema;\n\t\tcase \"object\": {\n\t\t\tif (value === null) {\n\t\t\t\treturn nullSchema;\n\t\t\t}\n\t\t\tassert(isFluidHandle(value), 0x87e /* invalid TreeValue */);\n\t\t\treturn handleSchema;\n\t\t}\n\t\tdefault:\n\t\t\tunreachableCase(value);\n\t}\n}\n\n/**\n * The name of a schema produced by {@link SchemaFactory}, including its optional scope prefix.\n *\n * @public\n */\nexport type ScopedSchemaName<\n\tTScope extends string | undefined,\n\tTName extends number | string,\n> = TScope extends undefined ? `${TName}` : `${TScope}.${TName}`;\n// > = `${TScope extends undefined ? \"\" : `${TScope}.`}${TName}`;\n\n// TODO:\n// SchemaFactory.array references should link to the correct overloads, however the syntax for this does not seems to work currently for methods unless the they are not qualified with the class.\n// API-Extractor requires such links to be qualified with the class, so it can't work.\n// Since linking the overload set as a whole also doesn't work, these have been made non-links for now.\n/**\n * Creates various types of {@link TreeNodeSchema|schema} for {@link TreeNode}s.\n *\n * @typeParam TScope - Scope added as a prefix to the name of every schema produced by this factory.\n * @typeParam TName - Type of names used to identify each schema produced in this factory.\n * Typically this is just `string` but it is also possible to use `string` or `number` based enums if you prefer to identify your types that way.\n *\n * @remarks\n * All schema produced by this factory get a {@link TreeNodeSchemaCore.identifier|unique identifier} by combining the {@link SchemaFactory.scope} with the schema's `Name`.\n * The `Name` part may be explicitly provided as a parameter, or inferred as a structural combination of the provided types.\n * The APIs which use this second approach, structural naming, also deduplicate all equivalent calls.\n * Therefor two calls to `array(allowedTypes)` with the same allowedTypes will return the same {@link TreeNodeSchema} instance.\n * On the other hand, two calls to `array(name, allowedTypes)` will always return different {@link TreeNodeSchema} instances\n * and it is an error to use both in the same tree (since their identifiers are not unique).\n *\n * Note:\n * POJO stands for Plain Old JavaScript Object.\n * This means an object that works like a `{}` style object literal.\n * In this case it means the prototype is `Object.prototype` and acts like a set of key value pairs (data, not methods).\n * The usage below generalizes this to include array and map like objects as well.\n *\n * There are two ways to use these APIs:\n * |                     | Customizable | POJO Emulation |\n * | ------------------- | ------------ |--------------- |\n * | Declaration         | `class X extends schemaFactory.object(\"x\", {}) {}` | `const X = schemaFactory.object(\"x\", {}); type X = NodeFromSchema<typeof X>; `\n * | Allows adding \"local\" (non-persisted) members | Yes. Members (including methods) can be added to class.        | No. Attempting to set non-field members will error. |\n * | Prototype | The user defined class | `Object.prototype`, `Map.prototype` or `Array.prototype` depending on node kind |\n * | Structurally named Schema | Not Supported | Supported |\n * | Explicitly named Objects | Supported | Supported |\n * | Explicitly named Maps and Arrays | Supported: Both declaration approaches can be used | Not Supported |\n * | node.js assert.deepEqual | Compares like class instances: equal to other nodes of the same type with the same content, including custom local fields. | Compares like plain objects: equal to plain JavaScript objects with the same fields, and other nodes with the same fields, even if the types are different. |\n * | IntelliSense | Shows and links to user defined class by name: `X` | Shows internal type generation logic: `object & TreeNode & ObjectFromSchemaRecord<{}> & WithType<\"test.x\">` |\n * | Recursion | Supported with special declaration patterns. | Unsupported: Generated d.ts files replace recursive references with `any`, breaking use of recursive schema across compilation boundaries |\n *\n * Note that while \"POJO Emulation\" nodes act a lot like POJO objects, they are not true POJO objects:\n *\n * - Adding new arbitrary fields will error, as well some cases of invalid edits.\n *\n * - They are implemented using proxies.\n *\n * - They have state that is not exposed via enumerable own properties, including a {@link TreeNodeSchema}.\n * This makes libraries like node.js `assert.deepEqual` fail to detect differences in type.\n *\n * - Assigning members has side effects (in this case editing the persisted/shared tree).\n *\n * - Not all operations implied by the prototype will work correctly: stick to the APIs explicitly declared in the TypeScript types.\n *\n * @privateRemarks\n * It's perfectly possible to make `POJO Emulation` mode (or even just hiding the prototype) selectable even when using the custom user class declaration syntax.\n * When doing this, it's still possible to make `instanceof` perform correctly.\n * Allowing (or banning) custom/out-of-schema properties on the class is also possible in both modes: it could be orthogonal.\n * Also for consistency, if keeping the current approach to detecting `POJO Emulation` mode it might make sense to make explicitly named Maps and Arrays do the detection the same as how object does it.\n *\n * @sealed @public\n */\nexport class SchemaFactory<\n\tout TScope extends string | undefined = string | undefined,\n\tTName extends number | string = string,\n> {\n\t/**\n\t * TODO:\n\t * If users of this generate the same name because two different schema with the same identifier were used,\n\t * the second use can get a cache hit, and reference the wrong schema.\n\t * Such usage should probably return a distinct type or error but currently does not.\n\t * The use of markSchemaMostDerived in structuralName at least ensure an error in the case where the collision is from two types extending the same schema factor class.\n\t */\n\tprivate readonly structuralTypes: Map<string, TreeNodeSchema> = new Map();\n\n\t/**\n\t * Construct a SchemaFactory with a given scope.\n\t * @remarks\n\t * There are no restrictions on mixing schema from different schema factories:\n\t * this is encouraged when a single schema references schema from different libraries.\n\t * If each library exporting schema picks its own globally unique scope for its SchemaFactory,\n\t * then all schema an application might depend on, directly or transitively,\n\t * will end up with a unique fully qualified name which is required to refer to it in persisted data and errors.\n\t *\n\t * @param scope - Prefix appended to the identifiers of all {@link TreeNodeSchema} produced by this builder.\n\t * Use of [Reverse domain name notation](https://en.wikipedia.org/wiki/Reverse_domain_name_notation) or a UUIDv4 is recommended to avoid collisions.\n\t * You may opt out of using a scope by passing `undefined`, but note that this increases the risk of collisions.\n\t */\n\tpublic constructor(public readonly scope: TScope) {}\n\n\tprivate scoped<Name extends TName | string>(name: Name): ScopedSchemaName<TScope, Name> {\n\t\treturn (\n\t\t\tthis.scope === undefined ? `${name}` : `${this.scope}.${name}`\n\t\t) as ScopedSchemaName<TScope, Name>;\n\t}\n\n\t/**\n\t * {@link TreeNodeSchema} for holding a JavaScript `string`.\n\t *\n\t * @remarks\n\t * Strings containing unpaired UTF-16 surrogate pair code units may not be handled correctly.\n\t *\n\t * These limitations come from the use of UTF-8 encoding of the strings, which requires them to be valid unicode.\n\t * JavaScript does not make this requirement for its strings so not all possible JavaScript strings are supported.\n\t * @privateRemarks\n\t * TODO:\n\t * We should be much more clear about what happens if you use problematic values.\n\t * We should validate and/or normalize them when inserting content.\n\t */\n\tpublic readonly string = stringSchema;\n\n\t/**\n\t * {@link TreeNodeSchema} for holding a JavaScript `number`.\n\t *\n\t * @remarks\n\t * The number is a [double-precision 64-bit binary format IEEE 754](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) value, however there are some exceptions:\n\t * - `NaN`, and the infinities are converted to `null` (and may therefore only be used where `null` is allowed by the schema).\n\t * - `-0` may be converted to `0` in some cases.\n\t *\n\t * These limitations match the limitations of JSON.\n\t * @privateRemarks\n\t * TODO:\n\t * We should be much more clear about what happens if you use problematic values.\n\t * We should validate and/or normalize them when inserting content.\n\t */\n\tpublic readonly number = numberSchema;\n\n\t/**\n\t * {@link TreeNodeSchema} for holding a boolean.\n\t */\n\tpublic readonly boolean = booleanSchema;\n\n\t/**\n\t * {@link TreeNodeSchema} for JavaScript `null`.\n\t *\n\t * @remarks\n\t * There are good [reasons to avoid using null](https://www.npmjs.com/package/%40rushstack/eslint-plugin#rushstackno-new-null) in JavaScript, however sometimes it is desired.\n\t * This {@link TreeNodeSchema} node provides the option to include nulls in trees when desired.\n\t * Unless directly inter-operating with existing data using null, consider other approaches, like wrapping the value in an optional field, or using a more specifically named empty object node.\n\t */\n\tpublic readonly null = nullSchema;\n\n\t/**\n\t * {@link TreeNodeSchema} for holding an {@link @fluidframework/core-interfaces#(IFluidHandle:interface)}.\n\t */\n\tpublic readonly handle = handleSchema;\n\n\t/**\n\t * Define a {@link TreeNodeSchemaClass} for a {@link TreeObjectNode}.\n\t *\n\t * @param name - Unique identifier for this schema within this factory's scope.\n\t * @param fields - Schema for fields of the object node's schema. Defines what children can be placed under each key.\n\t */\n\tpublic object<\n\t\tconst Name extends TName,\n\t\tconst T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,\n\t>(\n\t\tname: Name,\n\t\tfields: T,\n\t): TreeNodeSchemaClass<\n\t\tScopedSchemaName<TScope, Name>,\n\t\tNodeKind.Object,\n\t\tTreeObjectNode<T, ScopedSchemaName<TScope, Name>>,\n\t\tobject & InsertableObjectFromSchemaRecord<T>,\n\t\ttrue,\n\t\tT\n\t> {\n\t\treturn objectSchema(this.scoped(name), fields, true);\n\t}\n\n\t/**\n\t * Define a structurally typed {@link TreeNodeSchema} for a {@link TreeMapNode}.\n\t *\n\t * @remarks\n\t * The unique identifier for this Map is defined as a function of the provided types.\n\t * It is still scoped to this SchemaBuilder, but multiple calls with the same arguments will return the same schema object, providing somewhat structural typing.\n\t * This does not support recursive types.\n\t *\n\t * If using these structurally named maps, other types in this schema builder should avoid names of the form `Map<${string}>`.\n\t *\n\t * @example\n\t * The returned schema should be used as a schema directly:\n\t * ```typescript\n\t * const MyMap = factory.map(factory.number);\n\t * type MyMap = NodeFromSchema<typeof MyMap>;\n\t * ```\n\t * Or inline:\n\t * ```typescript\n\t * factory.object(\"Foo\", {myMap: factory.map(factory.number)});\n\t * ```\n\t * @privateRemarks\n\t * See note on array.\n\t */\n\tpublic map<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(\n\t\tallowedTypes: T,\n\t): TreeNodeSchema<\n\t\tScopedSchemaName<TScope, `Map<${string}>`>,\n\t\tNodeKind.Map,\n\t\tTreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>>,\n\t\tIterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>,\n\t\ttrue,\n\t\tT\n\t>;\n\n\t/**\n\t * Define a {@link TreeNodeSchema} for a {@link TreeMapNode}.\n\t *\n\t * @param name - Unique identifier for this schema within this factory's scope.\n\t *\n\t * @example\n\t * ```typescript\n\t * class NamedMap extends factory.map(\"name\", factory.number) {}\n\t * ```\n\t */\n\tpublic map<Name extends TName, const T extends ImplicitAllowedTypes>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t): TreeNodeSchemaClass<\n\t\tScopedSchemaName<TScope, Name>,\n\t\tNodeKind.Map,\n\t\tTreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>>,\n\t\tIterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>,\n\t\ttrue,\n\t\tT\n\t>;\n\n\tpublic map<const T extends ImplicitAllowedTypes>(\n\t\tnameOrAllowedTypes: TName | ((T & TreeNodeSchema) | readonly TreeNodeSchema[]),\n\t\tallowedTypes?: T,\n\t): TreeNodeSchema<\n\t\tstring,\n\t\tNodeKind.Map,\n\t\tTreeMapNode<T>,\n\t\tIterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>,\n\t\ttrue,\n\t\tT\n\t> {\n\t\tif (allowedTypes === undefined) {\n\t\t\tconst types = nameOrAllowedTypes as (T & TreeNodeSchema) | readonly TreeNodeSchema[];\n\t\t\tconst fullName = structuralName(\"Map\", types);\n\t\t\treturn getOrCreate(\n\t\t\t\tthis.structuralTypes,\n\t\t\t\tfullName,\n\t\t\t\t() =>\n\t\t\t\t\tthis.namedMap(\n\t\t\t\t\t\tfullName as TName,\n\t\t\t\t\t\tnameOrAllowedTypes as T,\n\t\t\t\t\t\tfalse,\n\t\t\t\t\t\ttrue,\n\t\t\t\t\t) as TreeNodeSchema,\n\t\t\t) as TreeNodeSchemaClass<\n\t\t\t\tstring,\n\t\t\t\tNodeKind.Map,\n\t\t\t\tTreeMapNode<T>,\n\t\t\t\tIterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>,\n\t\t\t\ttrue,\n\t\t\t\tT\n\t\t\t>;\n\t\t}\n\t\treturn this.namedMap(nameOrAllowedTypes as TName, allowedTypes, true, true);\n\t}\n\n\t/**\n\t * Define a {@link TreeNodeSchema} for a {@link (TreeMapNode:interface)}.\n\t *\n\t * @param name - Unique identifier for this schema within this factory's scope.\n\t */\n\tprivate namedMap<\n\t\tName extends TName | string,\n\t\tconst T extends ImplicitAllowedTypes,\n\t\tconst ImplicitlyConstructable extends boolean,\n\t>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t\tcustomizable: boolean,\n\t\timplicitlyConstructable: ImplicitlyConstructable,\n\t): TreeNodeSchemaClass<\n\t\tScopedSchemaName<TScope, Name>,\n\t\tNodeKind.Map,\n\t\tTreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>>,\n\t\tIterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>,\n\t\tImplicitlyConstructable,\n\t\tT\n\t> {\n\t\treturn mapSchema(\n\t\t\tthis.scoped(name),\n\t\t\tallowedTypes,\n\t\t\timplicitlyConstructable,\n\t\t\t// The current policy is customizable nodes don't get fake prototypes.\n\t\t\t!customizable,\n\t\t);\n\t}\n\n\t/**\n\t * Define a structurally typed {@link TreeNodeSchema} for a {@link (TreeArrayNode:interface)}.\n\t *\n\t * @remarks\n\t * The identifier for this Array is defined as a function of the provided types.\n\t * It is still scoped to this SchemaFactory, but multiple calls with the same arguments will return the same schema object, providing somewhat structural typing.\n\t * This does not support recursive types.\n\t *\n\t * If using these structurally named arrays, other types in this schema builder should avoid names of the form `Array<${string}>`.\n\t *\n\t * @example\n\t * The returned schema should be used as a schema directly:\n\t * ```typescript\n\t * const MyArray = factory.array(factory.number);\n\t * type MyArray = NodeFromSchema<typeof MyArray>;\n\t * ```\n\t * Or inline:\n\t * ```typescript\n\t * factory.object(\"Foo\", {myArray: factory.array(factory.number)});\n\t * ```\n\t * @privateRemarks\n\t * The name produced at the type level here is not as specific as it could be, however doing type level sorting and escaping is a real mess.\n\t * There are cases where not having this full type provided will be less than ideal since TypeScript's structural types.\n\t * For example attempts to narrow unions of structural arrays by name won't work.\n\t * Planned future changes to move to a class based schema system as well as factor function based node construction should mostly avoid these issues,\n\t * though there may still be some problematic cases even after that work is done.\n\t *\n\t * The return value is a class, but its the type is intentionally not specific enough to indicate it is a class.\n\t * This prevents callers of this from sub-classing it, which is unlikely to work well (due to the ease of accidentally giving two different calls o this different subclasses)\n\t * when working with structural typing.\n\t *\n\t * {@label STRUCTURAL}\n\t */\n\tpublic array<const T extends TreeNodeSchema | readonly TreeNodeSchema[]>(\n\t\tallowedTypes: T,\n\t): TreeNodeSchema<\n\t\tScopedSchemaName<TScope, `Array<${string}>`>,\n\t\tNodeKind.Array,\n\t\tTreeArrayNode<T> & WithType<ScopedSchemaName<TScope, `Array<${string}>`>>,\n\t\tIterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,\n\t\ttrue,\n\t\tT\n\t>;\n\n\t/**\n\t * Define (and add to this library) a {@link TreeNodeSchemaClass} for a {@link (TreeArrayNode:interface)}.\n\t *\n\t * @param name - Unique identifier for this schema within this factory's scope.\n\t *\n\t * @example\n\t * ```typescript\n\t * class NamedArray extends factory.array(\"name\", factory.number) {}\n\t * ```\n\t *\n\t * {@label NAMED}\n\t */\n\tpublic array<const Name extends TName, const T extends ImplicitAllowedTypes>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t): TreeNodeSchemaClass<\n\t\tScopedSchemaName<TScope, Name>,\n\t\tNodeKind.Array,\n\t\tTreeArrayNode<T> & WithType<ScopedSchemaName<TScope, Name>>,\n\t\tIterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,\n\t\ttrue,\n\t\tT\n\t>;\n\n\tpublic array<const T extends ImplicitAllowedTypes>(\n\t\tnameOrAllowedTypes: TName | ((T & TreeNodeSchema) | readonly TreeNodeSchema[]),\n\t\tallowedTypes?: T,\n\t): TreeNodeSchema<\n\t\tScopedSchemaName<TScope, string>,\n\t\tNodeKind.Array,\n\t\tTreeArrayNode<T>,\n\t\tIterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,\n\t\ttrue,\n\t\tT\n\t> {\n\t\tif (allowedTypes === undefined) {\n\t\t\tconst types = nameOrAllowedTypes as (T & TreeNodeSchema) | readonly TreeNodeSchema[];\n\t\t\tconst fullName = structuralName(\"Array\", types);\n\t\t\treturn getOrCreate(this.structuralTypes, fullName, () =>\n\t\t\t\tthis.namedArray(fullName, nameOrAllowedTypes as T, false, true),\n\t\t\t) as TreeNodeSchemaClass<\n\t\t\t\tScopedSchemaName<TScope, string>,\n\t\t\t\tNodeKind.Array,\n\t\t\t\tTreeArrayNode<T>,\n\t\t\t\tIterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,\n\t\t\t\ttrue,\n\t\t\t\tT\n\t\t\t>;\n\t\t}\n\t\treturn this.namedArray(nameOrAllowedTypes as TName, allowedTypes, true, true);\n\t}\n\n\t/**\n\t * Define a {@link TreeNodeSchema} for a {@link (TreeArrayNode:interface)}.\n\t *\n\t * @param name - Unique identifier for this schema within this factory's scope.\n\t *\n\t * @remarks\n\t * This is not intended to be used directly, use the overload of `array` which takes a name instead.\n\t * This is only public to work around a compiler limitation.\n\t */\n\tprivate namedArray<\n\t\tName extends TName | string,\n\t\tconst T extends ImplicitAllowedTypes,\n\t\tconst ImplicitlyConstructable extends boolean,\n\t>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t\tcustomizable: boolean,\n\t\timplicitlyConstructable: ImplicitlyConstructable,\n\t): TreeNodeSchemaClass<\n\t\tScopedSchemaName<TScope, Name>,\n\t\tNodeKind.Array,\n\t\tTreeArrayNode<T> & WithType<ScopedSchemaName<TScope, string>>,\n\t\tIterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,\n\t\tImplicitlyConstructable,\n\t\tT\n\t> {\n\t\treturn arraySchema(this.scoped(name), allowedTypes, implicitlyConstructable, customizable);\n\t}\n\n\t/**\n\t * Make a field optional instead of the default, which is required.\n\t *\n\t * @param t - The types allowed under the field.\n\t * @param props - Optional properties to associate with the field.\n\t */\n\tpublic optional<const T extends ImplicitAllowedTypes>(\n\t\tt: T,\n\t\tprops?: Omit<FieldProps, \"defaultProvider\">,\n\t): FieldSchema<FieldKind.Optional, T> {\n\t\tconst defaultOptionalProvider: DefaultProvider = getDefaultProvider(() => {\n\t\t\treturn undefined;\n\t\t});\n\t\treturn createFieldSchema(FieldKind.Optional, t, {\n\t\t\tdefaultProvider: defaultOptionalProvider,\n\t\t\t...props,\n\t\t});\n\t}\n\n\t/**\n\t * Make a field explicitly required.\n\t *\n\t * @param t - The types allowed under the field.\n\t * @param props - Optional properties to associate with the field.\n\t *\n\t * @remarks\n\t * Fields are required by default, but this API can be used to make the required nature explicit in the schema,\n\t * and allows associating custom {@link FieldProps | properties} with the field.\n\t */\n\tpublic required<const T extends ImplicitAllowedTypes>(\n\t\tt: T,\n\t\tprops?: Omit<FieldProps, \"defaultProvider\">,\n\t): FieldSchema<FieldKind.Required, T> {\n\t\treturn createFieldSchema(FieldKind.Required, t, props);\n\t}\n\n\t/**\n\t * {@link SchemaFactory.optional} except tweaked to work better for recursive types.\n\t * Use with {@link ValidateRecursiveSchema} for improved type safety.\n\t * @remarks\n\t * This version of {@link SchemaFactory.optional} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t */\n\tpublic optionalRecursive<const T extends Unenforced<ImplicitAllowedTypes>>(\n\t\tt: T,\n\t\tprops?: Omit<FieldProps, \"defaultProvider\">,\n\t): FieldSchemaUnsafe<FieldKind.Optional, T> {\n\t\treturn createFieldSchemaUnsafe(FieldKind.Optional, t, props);\n\t}\n\n\t/**\n\t * {@link SchemaFactory.required} except tweaked to work better for recursive types.\n\t * Use with {@link ValidateRecursiveSchema} for improved type safety.\n\t * @remarks\n\t * This version of {@link SchemaFactory.required} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t */\n\tpublic requiredRecursive<const T extends Unenforced<ImplicitAllowedTypes>>(\n\t\tt: T,\n\t\tprops?: Omit<FieldProps, \"defaultProvider\">,\n\t): FieldSchemaUnsafe<FieldKind.Required, T> {\n\t\treturn createFieldSchemaUnsafe(FieldKind.Required, t, props);\n\t}\n\n\t/**\n\t * A special field which holds a unique identifier for an object node.\n\t * @remarks\n\t * The value of this field, a \"node identifier\", uniquely identifies a node among all other nodes in the tree.\n\t * Node identifiers are strings, and can therefore be used as lookup keys in maps or written to a database.\n\t * When the node is constructed, the identifier field does not need to be populated.\n\t * The SharedTree will provide an identifier for the node automatically.\n\t * An identifier provided automatically by the SharedTree has the following properties:\n\t * - It is a UUID.\n\t * - It is compressed to a space-efficient representation when stored in the document.\n\t * - A compressed form of the identifier can be accessed at runtime via the `Tree.shortId()` API.\n\t * - 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.\n\t *\n\t * However, a user may alternatively supply their own string as the identifier if desired (for example, if importing identifiers from another system).\n\t * 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.\n\t * If the identifier is not unique, it may be read, but may cause libraries or features which operate over node identifiers to misbehave.\n\t * User-supplied identifiers may be read immediately, even before insertion into the tree.\n\t *\n\t * A node may have more than one identifier field (though note that this precludes the use of the `Tree.shortId()` API).\n\t */\n\tpublic get identifier(): FieldSchema<FieldKind.Identifier, typeof this.string> {\n\t\tconst defaultIdentifierProvider: DefaultProvider = getDefaultProvider(\n\t\t\t(nodeKeyManager: NodeKeyManager) => {\n\t\t\t\treturn nodeKeyManager.stabilizeNodeKey(nodeKeyManager.generateLocalNodeKey());\n\t\t\t},\n\t\t);\n\t\treturn createFieldSchema(FieldKind.Identifier, this.string, {\n\t\t\tdefaultProvider: defaultIdentifierProvider,\n\t\t});\n\t}\n\n\t/**\n\t * {@link SchemaFactory.object} except tweaked to work better for recursive types.\n\t * Use with {@link ValidateRecursiveSchema} for improved type safety.\n\t * @remarks\n\t * This version of {@link SchemaFactory.object} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t *\n\t * Additionally `ImplicitlyConstructable` is disabled (forcing use of constructor) to avoid\n\t * `error TS2589: Type instantiation is excessively deep and possibly infinite.`\n\t * which otherwise gets reported at sometimes incorrect source locations that vary based on incremental builds.\n\t */\n\t// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\n\tpublic objectRecursive<\n\t\tconst Name extends TName,\n\t\tconst T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>,\n\t>(name: Name, t: T) {\n\t\ttype TScopedName = ScopedSchemaName<TScope, Name>;\n\t\treturn this.object(\n\t\t\tname,\n\t\t\tt as T & RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,\n\t\t) as unknown as TreeNodeSchemaClass<\n\t\t\tTScopedName,\n\t\t\tNodeKind.Object,\n\t\t\tTreeObjectNodeUnsafe<T, TScopedName>,\n\t\t\tobject & InsertableObjectFromSchemaRecordUnsafe<T>,\n\t\t\tfalse,\n\t\t\tT\n\t\t>;\n\t}\n\n\t/**\n\t * `SchemaFactory.array` except tweaked to work better for recursive types.\n\t * Use with {@link ValidateRecursiveSchema} for improved type safety.\n\t * @remarks\n\t * This version of `SchemaFactory.array` uses the same workarounds as {@link SchemaFactory.objectRecursive}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t */\n\t// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\n\tpublic arrayRecursive<\n\t\tconst Name extends TName,\n\t\tconst T extends Unenforced<ImplicitAllowedTypes>,\n\t>(name: Name, allowedTypes: T) {\n\t\tconst RecursiveArray = this.namedArray(\n\t\t\tname,\n\t\t\tallowedTypes as T & ImplicitAllowedTypes,\n\t\t\ttrue,\n\t\t\tfalse,\n\t\t);\n\n\t\treturn RecursiveArray as TreeNodeSchemaClass<\n\t\t\tScopedSchemaName<TScope, Name>,\n\t\t\tNodeKind.Array,\n\t\t\tTreeArrayNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>,\n\t\t\t{\n\t\t\t\t/**\n\t\t\t\t * Iterator for the iterable of content for this node.\n\t\t\t\t * @privateRemarks\n\t\t\t\t * Wrapping the constructor parameter for recursive arrays and maps in an inlined object type avoids (for unknown reasons)\n\t\t\t\t * the following compile error when declaring the recursive schema:\n\t\t\t\t * `Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions.`\n\t\t\t\t * To benefit from this without impacting the API, the definition of `Iterable` has been inlined as such an object.\n\t\t\t\t *\n\t\t\t\t * If this workaround is kept, ideally this comment would be deduplicated with the other instance of it.\n\t\t\t\t * Unfortunately attempts to do this failed to avoid the compile error this was introduced to solve.\n\t\t\t\t */\n\t\t\t\t[Symbol.iterator](): Iterator<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>>;\n\t\t\t},\n\t\t\tfalse,\n\t\t\tT\n\t\t>;\n\t}\n\n\t/**\n\t * `SchemaFactory.map` except tweaked to work better for recursive types.\n\t * Use with {@link ValidateRecursiveSchema} for improved type safety.\n\t * @remarks\n\t * This version of `SchemaFactory.map` uses the same workarounds as {@link SchemaFactory.objectRecursive}.\n\t * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.\n\t */\n\t// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\n\tpublic mapRecursive<Name extends TName, const T extends Unenforced<ImplicitAllowedTypes>>(\n\t\tname: Name,\n\t\tallowedTypes: T,\n\t) {\n\t\tconst MapSchema = this.namedMap(\n\t\t\tname,\n\t\t\tallowedTypes as T & ImplicitAllowedTypes,\n\t\t\ttrue,\n\t\t\tfalse,\n\t\t);\n\n\t\treturn MapSchema as TreeNodeSchemaClass<\n\t\t\tScopedSchemaName<TScope, Name>,\n\t\t\tNodeKind.Map,\n\t\t\tTreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>,\n\t\t\t{\n\t\t\t\t/**\n\t\t\t\t * Iterator for the iterable of content for this node.\n\t\t\t\t * @privateRemarks\n\t\t\t\t * Wrapping the constructor parameter for recursive arrays and maps in an inlined object type avoids (for unknown reasons)\n\t\t\t\t * the following compile error when declaring the recursive schema:\n\t\t\t\t * `Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions.`\n\t\t\t\t * To benefit from this without impacting the API, the definition of `Iterable` has been inlined as such an object.\n\t\t\t\t *\n\t\t\t\t * If this workaround is kept, ideally this comment would be deduplicated with the other instance of it.\n\t\t\t\t * Unfortunately attempts to do this failed to avoid the compile error this was introduced to solve.\n\t\t\t\t */\n\t\t\t\t[Symbol.iterator](): Iterator<\n\t\t\t\t\t[string, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>]\n\t\t\t\t>;\n\t\t\t},\n\t\t\tfalse,\n\t\t\tT\n\t\t>;\n\t}\n}\n\nexport function structuralName<const T extends string>(\n\tcollectionName: T,\n\tallowedTypes: TreeNodeSchema | readonly TreeNodeSchema[],\n): `${T}<${string}>` {\n\tlet inner: string;\n\tif (!isReadonlyArray(allowedTypes)) {\n\t\treturn structuralName(collectionName, [allowedTypes]);\n\t} else {\n\t\tconst names = allowedTypes.map((t): string => {\n\t\t\t// Ensure that lazy types (functions) don't slip through here.\n\t\t\tassert(!isLazy(t), 0x83d /* invalid type provided */);\n\t\t\tmarkSchemaMostDerived(t);\n\t\t\treturn t.identifier;\n\t\t});\n\t\t// Ensure name is order independent\n\t\tnames.sort();\n\t\t// Ensure name can't have collisions by quoting and escaping any quotes in the names of types.\n\t\t// Using JSON is a simple way to accomplish this.\n\t\t// The outer `[]` around the result are also needed so that a single type name \"Any\" would not collide with the \"any\" case above.\n\t\tinner = JSON.stringify(names);\n\t}\n\treturn `${collectionName}<${inner}>`;\n}\n\n/**\n * Indicates that a schema is the \"most derived\" version which is allowed to be used, see {@link MostDerivedData}.\n * Calling helps with error messages about invalid schema usage (using more than one type from single schema factor produced type,\n * and thus calling this for one than one subclass).\n * @remarks\n * Helper for invoking {@link TreeNodeValid.markMostDerived} for any {@link TreeNodeSchema} if it needed.\n */\nexport function markSchemaMostDerived(schema: TreeNodeSchema): void {\n\tif (schema instanceof LeafNodeSchema) {\n\t\treturn;\n\t}\n\n\tif (!inPrototypeChain(schema, TreeNodeValid)) {\n\t\t// Use JSON.stringify to quote and escape identifier string.\n\t\tthrow new UsageError(\n\t\t\t`Schema for ${JSON.stringify(\n\t\t\t\tschema.identifier,\n\t\t\t)} does not extend a SchemaFactory generated class. This is invalid.`,\n\t\t);\n\t}\n\n\t(schema as typeof TreeNodeValid & TreeNodeSchema).markMostDerived();\n}\n"]}

package/lib/simple-tree/schemaFactoryRecursive.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemaFactoryRecursive.d.ts","sourceRoot":"","sources":["../../src/simple-tree/schemaFactoryRecursive.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,iBAAiB,CAAC;AAExE,OAAO,EACN,KAAK,SAAS,EACd,KAAK,UAAU,EAEf,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,KAAK,0CAA0C,EAC/C,KAAK,QAAQ,EACb,KAAK,mBAAmB,EACxB,KAAK,QAAQ,EACb,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,wBAAgB,uBAAuB,CACtC,IAAI,SAAS,SAAS,EACtB,KAAK,SAAS,UAAU,CAAC,oBAAoB,CAAC,EAE9C,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,KAAK,EACnB,KAAK,EAAE,UAAU,GAAG,SAAS,GAC3B,iBAAiB,CAAC,IAAI,EAAE,KAAK,CAAC,CAOhC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,MAAM,MAAM,uBAAuB,CAElC,CAAC,SAAS,mBAAmB,CAE5B,MAAM,EAEN,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,GAAG,GAAG,QAAQ,CAAC,MAAM,EAE/C,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,EAGpC;IACC,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,SAAS,yBAAyB,CAC7D,MAAM,EACN,mBAAmB,CACnB,GACE,gCAAgC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAC3C,OAAO,CAAC;IACX,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,SAAS,oBAAoB,GACrD,QAAQ,CAAC,0CAA0C,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAC/D,OAAO,CAAC;IACX,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,SAAS,oBAAoB,GACnD,QAAQ,CAAC,CAAC,MAAM,EAAE,0CAA0C,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GACzE,OAAO,CAAC;CACX,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAEZ,KAAK,EAEL;IACC,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,yBAAyB,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAC1E,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,oBAAoB,CAAC;IACvC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,oBAAoB,CAAC;CACrC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CACZ,IACE,IAAI,CAAC"}

package/lib/simple-tree/schemaFactoryRecursive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemaFactoryRecursive.js","sourceRoot":"","sources":["../../src/simple-tree/schemaFactoryRecursive.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,EAGN,iBAAiB,GAOjB,MAAM,kBAAkB,CAAC;AAI1B,MAAM,UAAU,uBAAuB,CAItC,IAAU,EACV,YAAmB,EACnB,KAA6B;IAE7B,kJAAkJ;IAClJ,OAAO,iBAAiB,CACvB,IAAI,EACJ,YAAoC,EACpC,KAAK,CAC6B,CAAC;AACrC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { Unenforced } from \"../feature-libraries/index.js\";\nimport type { RestrictiveReadonlyRecord } from \"../util/index.js\";\nimport type { InsertableObjectFromSchemaRecord } from \"./objectNode.js\";\n\nimport {\n\ttype FieldKind,\n\ttype FieldProps,\n\tcreateFieldSchema,\n\ttype ImplicitAllowedTypes,\n\ttype ImplicitFieldSchema,\n\ttype InsertableTreeNodeFromImplicitAllowedTypes,\n\ttype NodeKind,\n\ttype TreeNodeSchemaClass,\n\ttype WithType,\n} from \"./schemaTypes.js\";\nimport type { TreeNode } from \"./types.js\";\nimport type { FieldSchemaUnsafe } from \"./typesUnsafe.js\";\n\nexport function createFieldSchemaUnsafe<\n\tKind extends FieldKind,\n\tTypes extends Unenforced<ImplicitAllowedTypes>,\n>(\n\tkind: Kind,\n\tallowedTypes: Types,\n\tprops: FieldProps | undefined,\n): FieldSchemaUnsafe<Kind, Types> {\n\t// At runtime, we still want this to be a FieldSchema instance, but we can't satisfy its extends clause, so just return it as an FieldSchemaUnsafe\n\treturn createFieldSchema(\n\t\tkind,\n\t\tallowedTypes as ImplicitAllowedTypes,\n\t\tprops,\n\t) as FieldSchemaUnsafe<Kind, Types>;\n}\n\n/**\n * Compile time check for validity of a recursive schema.\n *\n * @example\n * ```typescript\n * class Test extends sf.arrayRecursive(\"Test\", [() => Test]) {}\n * {\n *     type _check = ValidateRecursiveSchema<typeof Test>;\n * }\n * ```\n * @remarks\n * The type of a recursive schema can be passed to this, and a compile error will be produced for some of the cases of malformed schema.\n * This can be used to help mitigate the issue that recursive schema definitions are {@link Unenforced}.\n * If an issue is encountered where a mistake in a recursive schema is made which produces an invalid schema but is not rejected by this checker,\n * it should be considered a bug and this should be updated to handle that case (or have a disclaimer added to these docs that it misses that case).\n *\n * # Recursive Schema\n *\n * The non-recursive versions of the schema building methods will run into several issues when used recursively.\n * Consider the following example:\n *\n * ```typescript\n * const Test = sf.array(Test); // Bad\n * ```\n *\n * This has several issues:\n *\n * 1. It is a structurally named schema.\n * Structurally named schema derive their name from the names of their child types, which is not possible when the type is recursive since its name would include itself.\n * Instead a name must be explicitly provided.\n *\n * 2. The schema accesses itself before it's defined.\n * This would be a runtime error if the TypeScript compiler allowed it.\n * This can be fixed by wrapping the type in a function, which also requires explicitly listing the allowed types in an array (`[() => Test]`).\n *\n * 3. TypeScript fails to infer the recursive type and falls back to `any` with this warning or error (depending on the compiler configuration):\n * `'Test' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.ts(7022)`.\n * This issue is what the specialized recursive schema building methods fix.\n * This fix comes at a cost: to make the recursive cases work, the `extends` clauses had to be removed.\n * This means that mistakes declaring recursive schema often don't give compile errors in the schema.\n * Additionally support for implicit construction had to be disabled.\n * This means that new nested {@link Unhydrated} nodes can not be created like `new Test([[]])`.\n * Instead the nested nodes must be created explicitly using the construction like`new Test([new Test([])])`.\n *\n * 4. It is using \"POJO\" mode since it's not explicitly declaring a new class.\n * This means that the generated d.ts files for the schema replace recursive references with `any`, breaking use of recursive schema across compilation boundaries.\n * This is fixed by explicitly creating a class which extends the returned schema.\n *\n * All together, the fixed version looks like:\n * ```typescript\n * class Test extends sf.arrayRecursive(\"Test\", [() => Test]) {} // Good\n * ```\n *\n * Be very careful when declaring recursive schema.\n * Due to the removed extends clauses, subtle mistakes will compile just fine but cause strange errors when the schema is used.\n *\n * For example if the square brackets around the allowed types are forgotten:\n *\n * ```typescript\n * class Test extends sf.arrayRecursive(\"Test\", () => Test) {} // Bad\n * ```\n * This schema will still compile, and some (but not all) usages of it may look like they work correctly while other usages will produce generally unintelligible compile errors.\n * This issue can be partially mitigated using {@link ValidateRecursiveSchema}:\n *\n * ```typescript\n * class Test extends sf.arrayRecursive(\"Test\", () => Test) {} // Bad\n * {\n *     type _check = ValidateRecursiveSchema<typeof Test>; // Reports compile error due to invalid schema above.\n * }\n * ```\n *\n * @privateRemarks\n * There are probably mistakes this misses: it's hard to guess all the wrong things people will accidentally do and defend against them.\n * Hopefully over time this can grow toward being robust, at least for common mistakes.\n *\n * This check duplicates logic that ideally would be entirely decided by the actual schema building methods.\n * Therefore changes to those methods may require updating `ValidateRecursiveSchema`.\n * @public\n */\nexport type ValidateRecursiveSchema<\n\t// Recursive types should always be using TreeNodeSchemaClass (not TreeNodeSchemaNonClass) as thats part of the requirements for the type to work across compilation boundaries correctly.\n\tT extends TreeNodeSchemaClass<\n\t\t// Name: This validator places no restrictions on the name other than that it's a string (as required by TreeNodeSchemaClass).\n\t\tstring,\n\t\t// NodeKind: These are the NodeKinds which currently can be used recursively.\n\t\tNodeKind.Array | NodeKind.Map | NodeKind.Object,\n\t\t// TNode: The produced node API. This is pretty minimal validation: more could be added if similar to how TInsertable works below if needed.\n\t\tTreeNode & WithType<T[\"identifier\"]>,\n\t\t// TInsertable: What can be passed to the constructor. This should be enough to catch most issues with incorrect schema.\n\t\t// These match whats defined in the recursive methods on `SchemaFactory` except they do not use `Unenforced`.\n\t\t{\n\t\t\t[NodeKind.Object]: T[\"info\"] extends RestrictiveReadonlyRecord<\n\t\t\t\tstring,\n\t\t\t\tImplicitFieldSchema\n\t\t\t>\n\t\t\t\t? InsertableObjectFromSchemaRecord<T[\"info\"]>\n\t\t\t\t: unknown;\n\t\t\t[NodeKind.Array]: T[\"info\"] extends ImplicitAllowedTypes\n\t\t\t\t? Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T[\"info\"]>>\n\t\t\t\t: unknown;\n\t\t\t[NodeKind.Map]: T[\"info\"] extends ImplicitAllowedTypes\n\t\t\t\t? Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T[\"info\"]>]>\n\t\t\t\t: unknown;\n\t\t}[T[\"kind\"]],\n\t\t// ImplicitlyConstructable: recursive types are not implicitly constructable.\n\t\tfalse,\n\t\t// Info: What's passed to the method to create the schema. Constraining these here should be about as effective as if the actual constraints existed on the actual method itself.\n\t\t{\n\t\t\t[NodeKind.Object]: RestrictiveReadonlyRecord<string, ImplicitFieldSchema>;\n\t\t\t[NodeKind.Array]: ImplicitAllowedTypes;\n\t\t\t[NodeKind.Map]: ImplicitAllowedTypes;\n\t\t}[T[\"kind\"]]\n\t>,\n> = true;\n"]}

package/lib/simple-tree/testRecursiveDomain.d.ts

@@ -1,61 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { FieldKind, NodeKind } from "./schemaTypes.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("./schemaTypes.js").TreeNodeSchemaClass<"Test Recursive Domain.testObject", NodeKind.Object, import("./typesUnsafe.js").TreeObjectNodeUnsafe<{
-    readonly recursive: import("./typesUnsafe.js").FieldSchemaUnsafe<FieldKind.Optional, readonly [() => typeof RecursiveObject]>;
-    readonly number: import("./schemaTypes.js").TreeNodeSchema<"com.fluidframework.leaf.number", NodeKind.Leaf, number, number>;
-}, "Test Recursive Domain.testObject">, object & {
-    readonly number: number;
-} & {
-    readonly recursive?: RecursiveObject | undefined;
-}, false, {
-    readonly recursive: import("./typesUnsafe.js").FieldSchemaUnsafe<FieldKind.Optional, readonly [() => typeof RecursiveObject]>;
-    readonly number: import("./schemaTypes.js").TreeNodeSchema<"com.fluidframework.leaf.number", NodeKind.Leaf, 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("./schemaTypes.js").TreeNodeSchemaClass<"Test Recursive Domain.testPOJOObject", NodeKind.Object, import("./typesUnsafe.js").TreeObjectNodeUnsafe<{
-    readonly recursive: import("./typesUnsafe.js").FieldSchemaUnsafe<FieldKind.Optional, readonly [() => import("./schemaTypes.js").TreeNodeSchemaClass<"Test Recursive Domain.testPOJOObject", NodeKind.Object, import("./typesUnsafe.js").TreeObjectNodeUnsafe<any, "Test Recursive Domain.testPOJOObject">, object & {
-        readonly number: number;
-    } & {
-        readonly recursive?: import("./typesUnsafe.js").TreeObjectNodeUnsafe<any, "Test Recursive Domain.testPOJOObject"> | undefined;
-    }, false, any>]>;
-    readonly number: import("./schemaTypes.js").TreeNodeSchema<"com.fluidframework.leaf.number", NodeKind.Leaf, number, number>;
-}, "Test Recursive Domain.testPOJOObject">, object & {
-    readonly number: number;
-} & {
-    readonly recursive?: import("./typesUnsafe.js").TreeObjectNodeUnsafe<{
-        readonly recursive: import("./typesUnsafe.js").FieldSchemaUnsafe<FieldKind.Optional, readonly [() => import("./schemaTypes.js").TreeNodeSchemaClass<"Test Recursive Domain.testPOJOObject", NodeKind.Object, import("./typesUnsafe.js").TreeObjectNodeUnsafe<any, "Test Recursive Domain.testPOJOObject">, object & {
-            readonly number: number;
-        } & any, false, any>]>;
-        readonly number: import("./schemaTypes.js").TreeNodeSchema<"com.fluidframework.leaf.number", NodeKind.Leaf, number, number>;
-    }, "Test Recursive Domain.testPOJOObject"> | undefined;
-}, false, {
-    readonly recursive: import("./typesUnsafe.js").FieldSchemaUnsafe<FieldKind.Optional, readonly [() => import("./schemaTypes.js").TreeNodeSchemaClass<"Test Recursive Domain.testPOJOObject", NodeKind.Object, import("./typesUnsafe.js").TreeObjectNodeUnsafe<any, "Test Recursive Domain.testPOJOObject">, object & {
-        readonly number: number;
-    } & {
-        readonly recursive?: import("./typesUnsafe.js").TreeObjectNodeUnsafe<any, "Test Recursive Domain.testPOJOObject"> | undefined;
-    }, false, any>]>;
-    readonly number: import("./schemaTypes.js").TreeNodeSchema<"com.fluidframework.leaf.number", NodeKind.Leaf, number, number>;
-}>;
-//# sourceMappingURL=testRecursiveDomain.d.ts.map

package/lib/simple-tree/testRecursiveDomain.d.ts.map

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

package/lib/simple-tree/testRecursiveDomain.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"testRecursiveDomain.js","sourceRoot":"","sources":["../../src/simple-tree/testRecursiveDomain.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAQnD,MAAM,OAAO,GAAG,IAAI,aAAa,CAAC,uBAAuB,CAAC,CAAC;AAE3D;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,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,MAAM,OAAO,eAAgB,SAAQ,IAAI;CAAG;AAE5C;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,OAAO,CAAC,eAAe,CAAC,gBAAgB,EAAE;IAChF,SAAS,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC,GAAG,EAAE,CAAC,uBAAuB,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, NodeKind } from \"./schemaTypes.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/lib/simple-tree/tree.d.ts.map

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

package/lib/simple-tree/tree.js

@@ -1,66 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { NodeKind, normalizeFieldSchema, } from "./schemaTypes.js";
-import { toFlexSchema } from "./toFlexSchema.js";
-import { LeafNodeSchema } from "./leafNodeSchema.js";
-import { assert } from "@fluidframework/core-utils/internal";
-import { isObjectNodeSchema } from "./objectNode.js";
-import { markSchemaMostDerived } from "./schemaFactory.js";
-const defaultTreeConfigurationOptions = {
-    enableSchemaValidation: false,
-};
-/**
- * Configuration for {@link ITree.viewWith}.
- * @sealed @public
- */
-export class TreeViewConfiguration {
-    /**
-     * @param props - Property bag of configuration options.
-     */
-    constructor(props) {
-        const config = { ...defaultTreeConfigurationOptions, ...props };
-        this.schema = config.schema;
-        this.enableSchemaValidation = config.enableSchemaValidation;
-        // Ensure all reachable schema are marked as most derived.
-        // This ensures if multiple schema extending the same schema factory generated class are present (or have been constructed, or get constructed in the future),
-        // an error is reported.
-        walkFieldSchema(config.schema, markSchemaMostDerived);
-        // Eagerly perform this conversion to surface errors sooner.
-        toFlexSchema(config.schema);
-    }
-}
-export function walkNodeSchema(schema, visitor, visitedSet) {
-    if (visitedSet.has(schema)) {
-        return;
-    }
-    visitedSet.add(schema);
-    if (schema instanceof LeafNodeSchema) {
-        // nothing to do
-    }
-    else if (isObjectNodeSchema(schema)) {
-        for (const field of schema.fields.values()) {
-            walkAllowedTypes(field.allowedTypeSet, visitor, visitedSet);
-        }
-    }
-    else {
-        assert(schema.kind === NodeKind.Array || schema.kind === NodeKind.Map, 0x9b3 /* invalid schema */);
-        const childTypes = schema.info;
-        walkFieldSchema(childTypes, visitor, visitedSet);
-    }
-    // This visit is done at the end so the traversal order is most inner types first.
-    // This was picked since when fixing errors,
-    // working from the inner types out to the types that use them will probably go better than the reverse.
-    // This does not however ensure all types referenced by a type are visited before it, since in recursive cases thats impossible.
-    visitor(schema);
-}
-export function walkFieldSchema(schema, visitor, visitedSet = new Set()) {
-    walkAllowedTypes(normalizeFieldSchema(schema).allowedTypeSet, visitor, visitedSet);
-}
-export function walkAllowedTypes(allowedTypes, visitor, visitedSet) {
-    for (const childType of allowedTypes) {
-        walkNodeSchema(childType, visitor, visitedSet);
-    }
-}
-//# sourceMappingURL=tree.js.map

package/lib/simple-tree/tree.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tree.js","sourceRoot":"","sources":["../../src/simple-tree/tree.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,OAAO,EAEN,QAAQ,EACR,oBAAoB,GAKpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAgE3D,MAAM,+BAA+B,GAAwC;IAC5E,sBAAsB,EAAE,KAAK;CAC7B,CAAC;AA2BF;;;GAGG;AACH,MAAM,OAAO,qBAAqB;IAajC;;OAEG;IACH,YAAmB,KAAsC;QACxD,MAAM,MAAM,GAAG,EAAE,GAAG,+BAA+B,EAAE,GAAG,KAAK,EAAE,CAAC;QAChE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,sBAAsB,GAAG,MAAM,CAAC,sBAAsB,CAAC;QAE5D,0DAA0D;QAC1D,8JAA8J;QAC9J,wBAAwB;QACxB,eAAe,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;QACtD,4DAA4D;QAC5D,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC7B,CAAC;CACD;AAED,MAAM,UAAU,cAAc,CAC7B,MAAsB,EACtB,OAAyC,EACzC,UAA+B;IAE/B,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5B,OAAO;IACR,CAAC;IACD,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACvB,IAAI,MAAM,YAAY,cAAc,EAAE,CAAC;QACtC,gBAAgB;IACjB,CAAC;SAAM,IAAI,kBAAkB,CAAC,MAAM,CAAC,EAAE,CAAC;QACvC,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;YAC5C,gBAAgB,CAAC,KAAK,CAAC,cAAc,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QAC7D,CAAC;IACF,CAAC;SAAM,CAAC;QACP,MAAM,CACL,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC,KAAK,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC,GAAG,EAC9D,KAAK,CAAC,oBAAoB,CAC1B,CAAC;QACF,MAAM,UAAU,GAAG,MAAM,CAAC,IAA4B,CAAC;QACvD,eAAe,CAAC,UAAU,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;IAClD,CAAC;IACD,kFAAkF;IAClF,4CAA4C;IAC5C,wGAAwG;IACxG,gIAAgI;IAChI,OAAO,CAAC,MAAM,CAAC,CAAC;AACjB,CAAC;AAED,MAAM,UAAU,eAAe,CAC9B,MAA2B,EAC3B,OAAyC,EACzC,aAAkC,IAAI,GAAG,EAAE;IAE3C,gBAAgB,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,cAAc,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;AACpF,CAAC;AAED,MAAM,UAAU,gBAAgB,CAC/B,YAAsC,EACtC,OAAyC,EACzC,UAA+B;IAE/B,KAAK,MAAM,SAAS,IAAI,YAAY,EAAE,CAAC;QACtC,cAAc,CAAC,SAAS,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;IAChD,CAAC;AACF,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { IFluidLoadable, IDisposable } from \"@fluidframework/core-interfaces\";\n\nimport type { CommitMetadata } from \"../core/index.js\";\nimport type { Listenable } from \"../events/index.js\";\nimport type { RevertibleFactory } from \"../shared-tree/index.js\";\n\nimport {\n\ttype ImplicitAllowedTypes,\n\tNodeKind,\n\tnormalizeFieldSchema,\n\ttype ImplicitFieldSchema,\n\ttype InsertableTreeFieldFromImplicitField,\n\ttype TreeFieldFromImplicitField,\n\ttype TreeNodeSchema,\n} from \"./schemaTypes.js\";\nimport { toFlexSchema } from \"./toFlexSchema.js\";\nimport { LeafNodeSchema } from \"./leafNodeSchema.js\";\nimport { assert } from \"@fluidframework/core-utils/internal\";\nimport { isObjectNodeSchema } from \"./objectNode.js\";\nimport { markSchemaMostDerived } from \"./schemaFactory.js\";\n\n/**\n * Channel for a Fluid Tree DDS.\n * @remarks\n * Allows storing and collaboratively editing schema-aware hierarchial data.\n * @sealed @public\n */\nexport interface ITree extends IFluidLoadable {\n\t/**\n\t * Returns a {@link TreeView} using the provided schema.\n\t * If the stored schema is compatible with the view schema specified by `config`,\n\t * the returned {@link TreeView} will expose the root with a schema-aware API based on the provided view schema.\n\t * If the provided schema is incompatible with the stored schema, the view will instead expose a status indicating the incompatibility.\n\t *\n\t * @remarks\n\t * If the tree is uninitialized (has no schema and no content), use {@link TreeView.initialize} on the returned view to set the schema and content together.\n\t * Using `viewWith` followed by {@link TreeView.upgradeSchema} to initialize only the schema for a document is technically valid when the schema\n\t * permits trees with no content.\n\t *\n\t * 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.\n\t *\n\t * Only one schematized view may exist for a given ITree at a time.\n\t * If creating a second, the first must be disposed before calling `viewWith` again.\n\t *\n\t * @privateRemarks\n\t * TODO: Provide a way to make a generic view schema for any document.\n\t * TODO: Support adapters for handling out-of-schema data.\n\t *\n\t * Doing initialization here allows a small API that is hard to use incorrectly.\n\t * Other approaches tend to have easy-to-make mistakes.\n\t * For example, having a separate initialization function means apps can forget to call it, making an app that can only open existing documents,\n\t * or call it unconditionally leaving an app that can only create new documents.\n\t * It also would require the schema to be passed into separate places and could cause issues if they didn't match.\n\t * Since the initialization function couldn't return a typed tree, the type checking wouldn't help catch that.\n\t * Also, if an app manages to create a document, but the initialization fails to get persisted, an app that only calls the initialization function\n\t * on the create code-path (for example how a schematized factory might do it),\n\t * would leave the document in an unusable state which could not be repaired when it is reopened (by the same or other clients).\n\t * Additionally, once out of schema content adapters are properly supported (with lazy document updates),\n\t * this initialization could become just another out of schema content adapter and this initialization is no longer a special case.\n\t */\n\tviewWith<TRoot extends ImplicitFieldSchema>(\n\t\tconfig: TreeViewConfiguration<TRoot>,\n\t): TreeView<TRoot>;\n}\n\n/**\n * Options when constructing a tree view.\n * @public\n */\nexport interface ITreeConfigurationOptions {\n\t/**\n\t * If `true`, the tree will validate new content against its stored schema at insertion time\n\t * and throw an error if the new content doesn't match the expected schema.\n\t *\n\t * @defaultValue `false`.\n\t *\n\t * @remarks Enabling schema validation has a performance penalty when inserting new content into the tree because\n\t * additional checks are done. Enable this option only in scenarios where you are ok with that operation being a\n\t * bit slower.\n\t */\n\tenableSchemaValidation?: boolean;\n}\n\nconst defaultTreeConfigurationOptions: Required<ITreeConfigurationOptions> = {\n\tenableSchemaValidation: false,\n};\n\n/**\n * Property-bag configuration for {@link TreeViewConfiguration} construction.\n * @public\n */\nexport interface ITreeViewConfiguration<\n\tTSchema extends ImplicitFieldSchema = ImplicitFieldSchema,\n> {\n\t/**\n\t * The schema which the application wants to view the tree with.\n\t */\n\treadonly schema: TSchema;\n\n\t/**\n\t * If `true`, the tree will validate new content against its stored schema at insertion time\n\t * and throw an error if the new content doesn't match the expected schema.\n\t *\n\t * @defaultValue `false`.\n\t *\n\t * @remarks Enabling schema validation has a performance penalty when inserting new content into the tree because\n\t * additional checks are done. Enable this option only in scenarios where you are ok with that operation being a\n\t * bit slower.\n\t */\n\treadonly enableSchemaValidation?: boolean;\n}\n\n/**\n * Configuration for {@link ITree.viewWith}.\n * @sealed @public\n */\nexport class TreeViewConfiguration<TSchema extends ImplicitFieldSchema = ImplicitFieldSchema>\n\timplements Required<ITreeViewConfiguration<TSchema>>\n{\n\t/**\n\t * {@inheritDoc ITreeViewConfiguration.schema}\n\t */\n\tpublic readonly schema: TSchema;\n\n\t/**\n\t * {@inheritDoc ITreeViewConfiguration.enableSchemaValidation}\n\t */\n\tpublic readonly enableSchemaValidation: boolean;\n\n\t/**\n\t * @param props - Property bag of configuration options.\n\t */\n\tpublic constructor(props: ITreeViewConfiguration<TSchema>) {\n\t\tconst config = { ...defaultTreeConfigurationOptions, ...props };\n\t\tthis.schema = config.schema;\n\t\tthis.enableSchemaValidation = config.enableSchemaValidation;\n\n\t\t// Ensure all reachable schema are marked as most derived.\n\t\t// This ensures if multiple schema extending the same schema factory generated class are present (or have been constructed, or get constructed in the future),\n\t\t// an error is reported.\n\t\twalkFieldSchema(config.schema, markSchemaMostDerived);\n\t\t// Eagerly perform this conversion to surface errors sooner.\n\t\ttoFlexSchema(config.schema);\n\t}\n}\n\nexport function walkNodeSchema(\n\tschema: TreeNodeSchema,\n\tvisitor: (schema: TreeNodeSchema) => void,\n\tvisitedSet: Set<TreeNodeSchema>,\n): void {\n\tif (visitedSet.has(schema)) {\n\t\treturn;\n\t}\n\tvisitedSet.add(schema);\n\tif (schema instanceof LeafNodeSchema) {\n\t\t// nothing to do\n\t} else if (isObjectNodeSchema(schema)) {\n\t\tfor (const field of schema.fields.values()) {\n\t\t\twalkAllowedTypes(field.allowedTypeSet, visitor, visitedSet);\n\t\t}\n\t} else {\n\t\tassert(\n\t\t\tschema.kind === NodeKind.Array || schema.kind === NodeKind.Map,\n\t\t\t0x9b3 /* invalid schema */,\n\t\t);\n\t\tconst childTypes = schema.info as ImplicitAllowedTypes;\n\t\twalkFieldSchema(childTypes, visitor, visitedSet);\n\t}\n\t// This visit is done at the end so the traversal order is most inner types first.\n\t// This was picked since when fixing errors,\n\t// working from the inner types out to the types that use them will probably go better than the reverse.\n\t// This does not however ensure all types referenced by a type are visited before it, since in recursive cases thats impossible.\n\tvisitor(schema);\n}\n\nexport function walkFieldSchema(\n\tschema: ImplicitFieldSchema,\n\tvisitor: (schema: TreeNodeSchema) => void,\n\tvisitedSet: Set<TreeNodeSchema> = new Set(),\n): void {\n\twalkAllowedTypes(normalizeFieldSchema(schema).allowedTypeSet, visitor, visitedSet);\n}\n\nexport function walkAllowedTypes(\n\tallowedTypes: Iterable<TreeNodeSchema>,\n\tvisitor: (schema: TreeNodeSchema) => void,\n\tvisitedSet: Set<TreeNodeSchema>,\n): void {\n\tfor (const childType of allowedTypes) {\n\t\twalkNodeSchema(childType, visitor, visitedSet);\n\t}\n}\n\n/**\n * An editable view of a (version control style) branch of a shared tree based on some schema.\n *\n * This schema--known as the view schema--may or may not align the stored schema of the document.\n * Information about discrepancies between the two schemas is available via {@link TreeView.compatibility | compatibility}.\n *\n * Application authors are encouraged to read [schema-evolution.md](../../docs/user-facing/schema-evolution.md) and\n * choose a schema compatibility policy that aligns with their application's needs.\n *\n * @privateRemarks\n * From an API design perspective, `upgradeSchema` could be merged into `viewWith` and/or `viewWith` could return errors explicitly on incompatible documents.\n * Such approaches would make it discoverable that out of schema handling may need to be done.\n * Doing that would however complicate trivial \"hello world\" style example slightly, as well as be a breaking API change.\n * It also seems more complex to handle invalidation with that pattern.\n * Thus this design was chosen at the risk of apps blindly accessing `root` then breaking unexpectedly when the document is incompatible.\n * @sealed @public\n */\nexport interface TreeView<TSchema extends ImplicitFieldSchema> extends IDisposable {\n\t/**\n\t * The current root of the tree.\n\t *\n\t * If the view schema not sufficiently compatible with the stored schema, accessing this will throw.\n\t * To handle this case, check {@link TreeView.compatibility | compatibility}'s {@link SchemaCompatibilityStatus.canView | canView} before using.\n\t *\n\t * To get notified about changes to this field,\n\t * use {@link TreeViewEvents.rootChanged} via `view.events.on(\"rootChanged\", callback)`.\n\t *\n\t * To get notified about changes to stored schema (which may affect compatibility between this view's schema and\n\t * the stored schema), use {@link TreeViewEvents.schemaChanged} via `view.events.on(\"schemaChanged\", callback)`.\n\t */\n\tget root(): TreeFieldFromImplicitField<TSchema>;\n\n\tset root(newRoot: InsertableTreeFieldFromImplicitField<TSchema>);\n\n\t/**\n\t * Description of the current compatibility status between the view schema and stored schema.\n\t *\n\t * {@link TreeViewEvents.schemaChanged} is fired when the compatibility status changes.\n\t */\n\treadonly compatibility: SchemaCompatibilityStatus;\n\n\t/**\n\t * When the schemas are not an exact match and {@link SchemaCompatibilityStatus.canUpgrade} is true,\n\t * this can be used to modify the stored schema to make it match the view schema.\n\t * This will update the compatibility state, and allow access to `root`.\n\t * Beware that this may impact other clients' ability to view the document depending on the application's schema compatibility policy!\n\t * @remarks\n\t * It is an error to call this when {@link SchemaCompatibilityStatus.canUpgrade} is false, and a no-op when the stored and view schema are already an exact match.\n\t * @privateRemarks\n\t * In the future, more upgrade options could be provided here.\n\t * Some options that could be added:\n\t * - check the actual document contents (not just the schema) and attempt an atomic document update if the data is compatible.\n\t * - apply converters and upgrade the document.\n\t * - apply converters to lazily to adapt the document to the requested view schema (with optional lazy schema updates or transparent conversions on write).\n\t */\n\tupgradeSchema(): void;\n\n\t/**\n\t * Initialize the tree, setting the stored schema to match this view's schema and setting the tree content.\n\t *\n\t * Only valid to call when this view's {@link SchemaCompatibilityStatus.canInitialize} is true.\n\t *\n\t * Applications should typically call this function before attaching a `SharedTree`.\n\t * @param content - The content to initialize the tree with.\n\t */\n\tinitialize(content: InsertableTreeFieldFromImplicitField<TSchema>): void;\n\n\t/**\n\t * Events for the tree.\n\t */\n\treadonly events: Listenable<TreeViewEvents>;\n}\n\n/**\n * Information about a view schema's compatibility with the document's stored schema.\n *\n * See SharedTree's README for more information about choosing a compatibility policy.\n * @sealed @public\n */\nexport interface SchemaCompatibilityStatus {\n\t/**\n\t * Whether the view schema allows exactly the same set of documents as the stored schema.\n\t *\n\t * @remarks\n\t * Equivalence here is defined in terms of allowed documents because there are some degenerate cases where schemas are not\n\t * exact matches in a strict (schema-based) sense but still allow the same documents, and the document notion is more useful to applications.\n\t *\n\t * Examples which are expressible where this may occur include:\n\t * - schema repository `A` has extra schema which schema `B` doesn't have, but they are unused (i.e. not reachable from the root schema)\n\t * - field in schema `A` has allowed field members which the corresponding field in schema `B` does not have, but those types are not constructible (ex: an object node type containing a required field with no allowed types)\n\t *\n\t * These cases are typically not interesting to applications.\n\t */\n\treadonly isEquivalent: boolean;\n\n\t/**\n\t * Whether the current view schema is sufficiently compatible with the stored schema to allow viewing tree data.\n\t * If false, {@link TreeView.root} will throw upon access.\n\t *\n\t * Currently, this field is true iff `isEquivalent` is true.\n\t * Do not rely on this:\n\t * there are near-term plans to extend support for viewing documents when the stored schema contains additional optional fields not present in the view schema.\n\t * The other two types of backward-compatible changes (field relaxations and addition of allowed field types) will eventually be supported as well,\n\t * likely through out-of-schema content adapters that the application can provide alongside their view schema.\n\t *\n\t * Be aware that even with these SharedTree limitations fixed, application logic may not correctly tolerate the documents allowable by the stored schema!\n\t * Application authors are encouraged to read docs/user-facing/schema-evolution.md and choose a schema compatibility policy that\n\t * aligns with their application's needs.\n\t *\n\t * @remarks\n\t * When the documents allowed by the view schema is a strict superset of those by the stored schema,\n\t * this is false because writes to the document using the view schema could make the document violate its stored schema.\n\t * In this case, the stored schema could be updated to match the provided view schema, allowing read-write access to the tree.\n\t * See {@link SchemaCompatibilityStatus.canUpgrade}.\n\t *\n\t * Future version of SharedTree may provide readonly access to the document in this case because that would be safe,\n\t * but this is not currently supported.\n\t *\n\t * @privateRemarks\n\t * A necessary condition for this to be true is that the documents allowed by the view schema are a subset of those allowed by the stored schema.\n\t * This is not sufficient: the simple-tree layer's read APIs do not tolerate out-of-schema data.\n\t * For example, if the view schema for a node has a required `Point` field but the stored schema has an optional `Point` field,\n\t * read APIs on the view schema do not work correctly when the document has a node with a missing `Point` field.\n\t * Similar issues happen when the view schema has a field with less allowed types than the stored schema and the document actually leverages those types.\n\t */\n\treadonly canView: boolean;\n\n\t/**\n\t * True iff the view schema supports all possible documents permitted by the stored schema.\n\t * When true, it is valid to call {@link TreeView.upgradeSchema} (though if the stored schema is already an exact match, this is a no-op).\n\t */\n\treadonly canUpgrade: boolean;\n\n\t/**\n\t * True iff the document is uninitialized (i.e. it has no schema and no content).\n\t *\n\t * To initialize the document, call {@link TreeView.initialize}.\n\t *\n\t * @remarks\n\t * It's not necessary to check this field before calling {@link TreeView.initialize} in most scenarios; application authors typically know from\n\t * context that they're in a flow which creates a new `SharedTree` and would like to initialize it.\n\t */\n\treadonly canInitialize: boolean;\n\n\t// TODO: Consider extending this status to include:\n\t// - application-defined metadata about the stored schema\n\t// - details about the differences between the stored and view schema sufficient for implementing \"safe mismatch\" policies\n}\n\n/**\n * Events for {@link TreeView}.\n * @sealed @public\n */\nexport interface TreeViewEvents {\n\t/**\n\t * Raised whenever {@link TreeView.root} is invalidated.\n\t *\n\t * This includes changes to the document schema.\n\t * It also includes changes to the field containing the root such as setting or clearing an optional root or changing which node is the root.\n\t * This does NOT include changes to the content (fields/children) of the root node: for that case subscribe to events on the root node.\n\t */\n\trootChanged(): void;\n\n\t/**\n\t * The stored schema for the document has changed.\n\t * This may affect the compatibility between the view schema and the stored schema, and thus the ability to use the view.\n\t *\n\t * @remarks\n\t * This event implies that the old {@link TreeView.root} is no longer valid, but applications need not handle that separately:\n\t * {@link TreeViewEvents.rootChanged} will be fired after this event.\n\t */\n\tschemaChanged(): void;\n\n\t/**\n\t * Fired when:\n\t * - a local commit is applied outside of a transaction\n\t * - a local transaction is committed\n\t *\n\t * The event is not fired when:\n\t * - a local commit is applied within a transaction\n\t * - a remote commit is applied\n\t *\n\t * @param data - information about the commit that was applied\n\t * @param getRevertible - a function provided that allows users to get a revertible for the commit that was applied. If not provided,\n\t * this commit is not revertible.\n\t */\n\tcommitApplied(data: CommitMetadata, getRevertible?: RevertibleFactory): void;\n}\n"]}

package/lib/simple-tree/treeNodeApi.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"treeNodeApi.d.ts","sourceRoot":"","sources":["../../src/simple-tree/treeNodeApi.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAEN,KAAK,UAAU,EAIf,MAAM,+BAA+B,CAAC;AAMvC,OAAO,EACN,QAAQ,EACR,KAAK,aAAa,EAClB,KAAK,cAAc,EAGnB,KAAK,oBAAoB,EACzB,KAAK,gCAAgC,EACrC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAY7D;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,WAAW;IAC3B;;OAEG;IACH,MAAM,CAAC,CAAC,SAAS,QAAQ,GAAG,aAAa,EACxC,IAAI,EAAE,CAAC,GACL,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IAEhD;;;;;;;;OAQG;IACH,EAAE,CAAC,OAAO,SAAS,oBAAoB,EACtC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,OAAO,GACb,KAAK,IAAI,gCAAgC,CAAC,OAAO,CAAC,CAAC;IAEtD;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;IAE7C;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;IAErC;;;;;;;OAOG;IACH,EAAE,CAAC,CAAC,SAAS,MAAM,gBAAgB,EAClC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAC3B,MAAM,IAAI,CAAC;IAEd;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IAEnC;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACrD;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,WAwFzB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC7B,KAAK,EAAE,CAAC,GACN,SAAS,GAAG,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC,CAwB1D"}

package/lib/simple-tree/treeNodeApi.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"treeNodeApi.js","sourceRoot":"","sources":["../../src/simple-tree/treeNodeApi.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\n\nimport { Multiplicity, rootFieldKey } from \"../core/index.js\";\nimport {\n\ttype LazyItem,\n\ttype TreeStatus,\n\tisLazy,\n\tisTreeValue,\n\tFlexObjectNodeSchema,\n} from \"../feature-libraries/index.js\";\nimport { fail, extractFromOpaque, isReadonlyArray } from \"../util/index.js\";\n\nimport { getOrCreateNodeProxy, isTreeNode } from \"./proxies.js\";\nimport { getFlexNode, getKernel } from \"./proxyBinding.js\";\nimport { tryGetSimpleNodeSchema } from \"./schemaCaching.js\";\nimport {\n\tNodeKind,\n\ttype TreeLeafValue,\n\ttype TreeNodeSchema,\n\ttype ImplicitFieldSchema,\n\tFieldSchema,\n\ttype ImplicitAllowedTypes,\n\ttype TreeNodeFromImplicitAllowedTypes,\n} from \"./schemaTypes.js\";\nimport type { TreeNode, TreeChangeEvents } from \"./types.js\";\nimport {\n\tbooleanSchema,\n\thandleSchema,\n\tnullSchema,\n\tnumberSchema,\n\tstringSchema,\n} from \"./leafNodeSchema.js\";\nimport { isFluidHandle } from \"@fluidframework/runtime-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\nimport type { Off } from \"../events/index.js\";\n\n/**\n * Provides various functions for analyzing {@link TreeNode}s.\n * * @remarks\n * This type should only be used via the public `Tree` export.\n * @privateRemarks\n * Due to limitations of API-Extractor link resolution, this type can't be moved into internalTypes but should be considered just an implementation detail of the `Tree` export.\n *\n * Inlining the typing of this interface onto the `Tree` object provides slightly different .d.ts generation,\n * which avoids typescript expanding the type of TreeNodeSchema and thus encountering\n * https://github.com/microsoft/rushstack/issues/1958.\n * @sealed @public\n */\nexport interface TreeNodeApi {\n\t/**\n\t * The schema information for this node.\n\t */\n\tschema<T extends TreeNode | TreeLeafValue>(\n\t\tnode: T,\n\t): TreeNodeSchema<string, NodeKind, unknown, T>;\n\n\t/**\n\t * Narrow the type of the given value if it satisfies the given schema.\n\t * @example\n\t * ```ts\n\t * if (node.is(myNode, Point)) {\n\t *     const y = myNode.y; // `myNode` is now known to satisfy the `Point` schema and therefore has a `y` coordinate.\n\t * }\n\t * ```\n\t */\n\tis<TSchema extends ImplicitAllowedTypes>(\n\t\tvalue: unknown,\n\t\tschema: TSchema,\n\t): value is TreeNodeFromImplicitAllowedTypes<TSchema>;\n\n\t/**\n\t * Return the node under which this node resides in the tree (or undefined if this is a root node of the tree).\n\t */\n\tparent(node: TreeNode): TreeNode | undefined;\n\n\t/**\n\t * The key of the given node under its parent.\n\t * @remarks\n\t * If `node` is an element in a {@link (TreeArrayNode:interface)}, this returns the index of `node` in the array node (a `number`).\n\t * Otherwise, this returns the key of the field that it is under (a `string`).\n\t */\n\tkey(node: TreeNode): string | number;\n\n\t/**\n\t * Register an event listener on the given node.\n\t * @param node - The node whose events should be subscribed to.\n\t * @param eventName - Which event to subscribe to.\n\t * @param listener - The callback to trigger for the event. The tree can be read during the callback, but it is invalid to modify the tree during this callback.\n\t * @returns A callback function which will deregister the event.\n\t * This callback should be called only once.\n\t */\n\ton<K extends keyof TreeChangeEvents>(\n\t\tnode: TreeNode,\n\t\teventName: K,\n\t\tlistener: TreeChangeEvents[K],\n\t): () => void;\n\n\t/**\n\t * Returns the {@link TreeStatus} of the given node.\n\t */\n\tstatus(node: TreeNode): TreeStatus;\n\n\t/**\n\t * Returns the {@link SchemaFactory.identifier | identifier} of the given node in the most compressed form possible.\n\t * @remarks\n\t * 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.\n\t * 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.\n\t *\n\t * If the node's identifier is any other user-provided string, then this will return that string.\n\t *\n\t * If the node has no identifier (that is, it has no {@link SchemaFactory.identifier | identifier} field), then this returns `undefined`.\n\t *\n\t * If the node has more than one identifier, then this will throw an error.\n\t *\n\t * The returned integer must not be serialized or preserved outside of the current process.\n\t * 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.\n\t * 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.\n\t */\n\tshortId(node: TreeNode): number | string | undefined;\n}\n\n/**\n * The `Tree` object holds various functions for analyzing {@link TreeNode}s.\n */\nexport const treeNodeApi: TreeNodeApi = {\n\tparent(node: TreeNode): TreeNode | undefined {\n\t\tconst editNode = getFlexNode(node).parentField.parent.parent;\n\t\tif (editNode === undefined) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst output = getOrCreateNodeProxy(editNode);\n\t\tassert(\n\t\t\t!isTreeValue(output),\n\t\t\t0x87f /* Parent can't be a leaf, so it should be a node not a value */,\n\t\t);\n\t\treturn output;\n\t},\n\tkey(node: TreeNode): string | number {\n\t\t// If the parent is undefined, then this node is under the root field,\n\t\t// so we know its key is the special root one.\n\t\tconst parent = treeNodeApi.parent(node);\n\t\tif (parent === undefined) {\n\t\t\treturn rootFieldKey;\n\t\t}\n\n\t\t// The flex-domain strictly operates in terms of \"stored keys\".\n\t\t// To find the associated developer-facing \"view key\", we need to look up the field associated with\n\t\t// the stored key from the flex-domain, and get view key its simple-domain counterpart was created with.\n\t\tconst storedKey = getStoredKey(node);\n\t\tconst parentSchema = treeNodeApi.schema(parent);\n\t\tconst viewKey = getViewKeyFromStoredKey(parentSchema, storedKey);\n\t\treturn viewKey;\n\t},\n\ton<K extends keyof TreeChangeEvents>(\n\t\tnode: TreeNode,\n\t\teventName: K,\n\t\tlistener: TreeChangeEvents[K],\n\t): Off {\n\t\treturn getKernel(node).on(eventName, listener);\n\t},\n\tstatus(node: TreeNode): TreeStatus {\n\t\treturn getKernel(node).getStatus();\n\t},\n\tis<TSchema extends ImplicitAllowedTypes>(\n\t\tvalue: unknown,\n\t\tschema: TSchema,\n\t): value is TreeNodeFromImplicitAllowedTypes<TSchema> {\n\t\tconst actualSchema = tryGetSchema(value);\n\t\tif (actualSchema === undefined) {\n\t\t\treturn false;\n\t\t}\n\t\tif (isReadonlyArray<LazyItem<TreeNodeSchema>>(schema)) {\n\t\t\tfor (const singleSchema of schema) {\n\t\t\t\tconst testSchema = isLazy(singleSchema) ? singleSchema() : singleSchema;\n\t\t\t\tif (testSchema === actualSchema) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t} else {\n\t\t\treturn (schema as TreeNodeSchema) === actualSchema;\n\t\t}\n\t},\n\tschema<T extends TreeNode | TreeLeafValue>(\n\t\tnode: T,\n\t): TreeNodeSchema<string, NodeKind, unknown, T> {\n\t\treturn tryGetSchema(node) ?? fail(\"Not a tree node\");\n\t},\n\tshortId(node: TreeNode): number | string | undefined {\n\t\tconst flexNode = getFlexNode(node);\n\t\tconst flexSchema = flexNode.schema;\n\t\tconst identifierFieldKeys =\n\t\t\tflexSchema instanceof FlexObjectNodeSchema ? flexSchema.identifierFieldKeys : [];\n\n\t\tswitch (identifierFieldKeys.length) {\n\t\t\tcase 0:\n\t\t\t\treturn undefined;\n\t\t\tcase 1: {\n\t\t\t\tconst identifier = flexNode.tryGetField(identifierFieldKeys[0])?.boxedAt(0);\n\t\t\t\tassert(identifier !== undefined, 0x927 /* The identifier must exist */);\n\t\t\t\tconst identifierValue = identifier.value as string;\n\t\t\t\tconst localNodeKey =\n\t\t\t\t\tidentifier.context.nodeKeyManager.tryLocalizeNodeKey(identifierValue);\n\t\t\t\treturn localNodeKey !== undefined ? extractFromOpaque(localNodeKey) : identifierValue;\n\t\t\t}\n\t\t\tdefault:\n\t\t\t\tthrow new UsageError(\n\t\t\t\t\t\"shortId() may not be called on a node with more than one identifier. Consider converting extraneous identifier fields to string fields.\",\n\t\t\t\t);\n\t\t}\n\t},\n};\n\n/**\n * Returns a schema for a value if the value is a {@link TreeNode} or a {@link TreeLeafValue}.\n * Returns undefined for other values.\n */\nexport function tryGetSchema<T>(\n\tvalue: T,\n): undefined | TreeNodeSchema<string, NodeKind, unknown, T> {\n\ttype TOut = TreeNodeSchema<string, NodeKind, unknown, T>;\n\tswitch (typeof value) {\n\t\tcase \"string\":\n\t\t\treturn stringSchema as TOut;\n\t\tcase \"number\":\n\t\t\treturn numberSchema as TOut;\n\t\tcase \"boolean\":\n\t\t\treturn booleanSchema as TOut;\n\t\tcase \"object\": {\n\t\t\tif (isTreeNode(value)) {\n\t\t\t\t// This case could be optimized, for example by placing the simple schema in a symbol on tree nodes.\n\t\t\t\treturn tryGetSimpleNodeSchema(getFlexNode(value).schema) as TOut;\n\t\t\t}\n\t\t\tif (value === null) {\n\t\t\t\treturn nullSchema as TOut;\n\t\t\t}\n\t\t\tif (isFluidHandle(value)) {\n\t\t\t\treturn handleSchema as TOut;\n\t\t\t}\n\t\t}\n\t\tdefault:\n\t\t\treturn undefined;\n\t}\n}\n\n/**\n * Gets the stored key with which the provided node is associated in the parent.\n */\nfunction getStoredKey(node: TreeNode): string | number {\n\t// Note: the flex domain strictly works with \"stored keys\", and knows nothing about the developer-facing\n\t// \"view keys\".\n\tconst parentField = getFlexNode(node).parentField;\n\tif (parentField.parent.schema.kind.multiplicity === Multiplicity.Sequence) {\n\t\t// The parent of `node` is an array node\n\t\treturn parentField.index;\n\t}\n\n\t// The parent of `node` is an object, a map, or undefined (and therefore `node` is a root/detached node).\n\treturn parentField.parent.key;\n}\n\n/**\n * Given a node schema, gets the view key corresponding with the provided {@link FieldProps.key | stored key}.\n */\nfunction getViewKeyFromStoredKey(\n\tschema: TreeNodeSchema,\n\tstoredKey: string | number,\n): string | number {\n\t// Only object nodes have the concept of a \"stored key\", differentiated from the developer-facing \"view key\".\n\t// For any other kind of node, the stored key and the view key are the same.\n\tif (schema.kind !== NodeKind.Object) {\n\t\treturn storedKey;\n\t}\n\n\tconst fields = schema.info as Record<string, ImplicitFieldSchema>;\n\n\t// Invariants:\n\t// - The set of all view keys under an object must be unique.\n\t// - The set of all stored keys (including those implicitly created from view keys) must be unique.\n\t// To find the view key associated with the provided stored key, first check for any stored key matches (which are optionally populated).\n\t// If we don't find any, then search for a matching view key.\n\tfor (const [viewKey, fieldSchema] of Object.entries(fields)) {\n\t\tif (fieldSchema instanceof FieldSchema && fieldSchema.props?.key === storedKey) {\n\t\t\treturn viewKey;\n\t\t}\n\t}\n\n\tif (fields[storedKey] === undefined) {\n\t\tfail(\"Existing stored key should always map to a view key\");\n\t}\n\n\treturn storedKey;\n}\n"]}