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

package/api-extractor-esm.json

@@ -1,14 +0,0 @@
-{
-	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-	"extends": "../../../common/build/build-common/api-extractor-base.esm.primary.json",
-	"compiler": {
-		// api-extractor has trouble with Node16 moduleResolution, but Bundler looks okay.
-		"overrideTsconfig": {
-			"$schema": "http://json.schemastore.org/tsconfig",
-			"extends": "./tsconfig.json",
-			"compilerOptions": {
-				"moduleResolution": "Bundler"
-			}
-		}
-	}
-}

package/dist/feature-libraries/multiplicity.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"multiplicity.d.ts","sourceRoot":"","sources":["../../src/feature-libraries/multiplicity.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH;;;;;GAKG;AACH,oBAAY,YAAY;IACvB;;OAEG;IACH,MAAM,IAAA;IACN;;OAEG;IACH,QAAQ,IAAA;IACR;;OAEG;IACH,QAAQ,IAAA;IACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,SAAS,IAAA;CACT"}

package/dist/feature-libraries/multiplicity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"multiplicity.js","sourceRoot":"","sources":["../../src/feature-libraries/multiplicity.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH;;;;;GAKG;AACH,IAAY,YA2CX;AA3CD,WAAY,YAAY;IACvB;;OAEG;IACH,mDAAM,CAAA;IACN;;OAEG;IACH,uDAAQ,CAAA;IACR;;OAEG;IACH,uDAAQ,CAAA;IACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,yDAAS,CAAA;AACV,CAAC,EA3CW,YAAY,4BAAZ,YAAY,QA2CvB","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n/**\n * Describes how a particular field functions.\n *\n * This determine its reading and editing APIs, multiplicity, and what merge resolution policies it will use.\n * @internal\n */\nexport enum Multiplicity {\n\t/**\n\t * Exactly one item.\n\t */\n\tSingle,\n\t/**\n\t * 0 or 1 items.\n\t */\n\tOptional,\n\t/**\n\t * 0 or more items.\n\t */\n\tSequence,\n\t/**\n\t * Exactly 0 items.\n\t *\n\t * Using Forbidden makes what types are listed for allowed in a field irrelevant\n\t * since the field will never have values in it.\n\t *\n\t * Using Forbidden is equivalent to picking a kind that permits empty (like sequence or optional)\n\t * and having no allowed types (or only never types).\n\t * Because of this, its possible to express everything constraint wise without Forbidden,\n\t * but using Forbidden can be more semantically clear than optional with no allowed types.\n\t *\n\t * For view schema, this can be useful if you need to:\n\t * - run a specific out of schema handler when a field is present,\n\t * but otherwise are ignoring or tolerating (ex: via extra fields) unmentioned fields.\n\t * - prevent a specific field from being used as an extra field\n\t * (perhaps for some past of future compatibility reason)\n\t * - keep a field in a schema for metadata purposes\n\t * (ex: for improved error messaging, error handling or documentation)\n\t * that is not used in this specific version of the schema (ex: to document what it was or will be used for).\n\t *\n\t * For stored schema, this can be useful if you need to:\n\t * - have a field which can have its schema updated to Optional or Sequence of any type.\n\t * - to exclude a field from extra fields\n\t * - for the schema system to use as a default for fields which aren't declared\n\t * (ex: when updating a field that did not exist into one that does)\n\t *\n\t * @privateRemarks\n\t * See storedEmptyFieldSchema for a constant, reusable field using Forbidden.\n\t */\n\tForbidden,\n}\n"]}

package/dist/feature-libraries/optional-field/optionalFieldChangeFormat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"optionalFieldChangeFormat.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/optional-field/optionalFieldChangeFormat.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAiB,OAAO,EAAQ,MAAM,mBAAmB,CAAC;AAOzE,eAAO,MAAM,iBAAiB,iiBAAiD,CAAC;AAChF,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEjE,eAAO,MAAM,YAAY,8fAAoC,CAAC;AAC9D,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,OAAO,YAAY,CAAC,CAAC;AAEvD,eAAO,MAAM,wBAAwB;;;;;EASnC,CAAC;AAEH,MAAM,MAAM,wBAAwB,CAAC,MAAM,SAAS,OAAO,IAAI,MAAM,CACpE,UAAU,CAAC,OAAO,wBAAwB,CAAC,MAAM,CAAC,CAAC,CACnD,CAAC"}

package/dist/feature-libraries/optional-field/optionalFieldChangeFormat.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"optionalFieldChangeFormat.js","sourceRoot":"","sources":["../../../src/feature-libraries/optional-field/optionalFieldChangeFormat.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,+CAAyE;AACzE,yDAAiE;AAEjE,MAAM,iBAAiB,GAAkB,EAAE,oBAAoB,EAAE,KAAK,EAAE,CAAC;AAEzE,gGAAgG;AAChG,+FAA+F;AAClF,QAAA,iBAAiB,GAAG,cAAI,CAAC,KAAK,CAAC,CAAC,8BAAmB,EAAE,cAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAGnE,QAAA,YAAY,GAAG,cAAI,CAAC,KAAK,CAAC,CAAC,8BAAmB,CAAC,CAAC,CAAC;AAGvD,MAAM,wBAAwB,GAAG,CAAyB,WAAmB,EAAE,EAAE,CACvF,cAAI,CAAC,MAAM,CACV;IACC,CAAC,EAAE,cAAI,CAAC,QAAQ,CAAC,cAAI,CAAC,KAAK,CAAC,oBAAY,CAAC,CAAC;IAC1C,CAAC,EAAE,YAAY;IACf,CAAC,EAAE,mBAAmB,CAAC,WAAW,CAAC;IACnC,CAAC,EAAE,cAAI,CAAC,QAAQ,CAAC,yBAAiB,CAAC;CACnC,EACD,iBAAiB,CACjB,CAAC;AATU,QAAA,wBAAwB,4BASlC;AAMH,MAAM,mBAAmB,GAAG,CAAyB,WAAmB,EAAE,EAAE,CAC3E,cAAI,CAAC,QAAQ,CAAC,cAAI,CAAC,KAAK,CAAC,cAAI,CAAC,KAAK,CAAC,CAAC,yBAAiB,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;AAEzE,+FAA+F;AAC/F,kEAAkE;AAClE,0HAA0H;AAC1H,yFAAyF;AACzF,MAAM,YAAY,GAAG,cAAI,CAAC,QAAQ,CACjC,cAAI,CAAC,KAAK,CAAC,cAAI,CAAC,KAAK,CAAC,CAAC,yBAAiB,EAAE,yBAAiB,EAAE,cAAI,CAAC,QAAQ,CAAC,cAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAC7F,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { Static, ObjectOptions, TSchema, Type } from \"@sinclair/typebox\";\nimport { EncodedChangeAtomId } from \"../modular-schema/index.js\";\n\nconst noAdditionalProps: ObjectOptions = { additionalProperties: false };\n\n// `null` signifies \"self\". Using undefined doesn't actually JSON round-trip conveniently, since\n// undefined is converted to null when inside an array (which happens in e.g. the moves array).\nexport const EncodedRegisterId = Type.Union([EncodedChangeAtomId, Type.Null()]);\nexport type EncodedRegisterId = Static<typeof EncodedRegisterId>;\n\nexport const EncodedBuild = Type.Tuple([EncodedChangeAtomId]);\nexport type EncodedBuild = Static<typeof EncodedBuild>;\n\nexport const EncodedOptionalChangeset = <Schema extends TSchema>(tNodeChange: Schema) =>\n\tType.Object(\n\t\t{\n\t\t\tb: Type.Optional(Type.Array(EncodedBuild)),\n\t\t\tm: EncodedMoves,\n\t\t\tc: EncodedChildChanges(tNodeChange),\n\t\t\td: Type.Optional(EncodedRegisterId),\n\t\t},\n\t\tnoAdditionalProps,\n\t);\n\nexport type EncodedOptionalChangeset<Schema extends TSchema> = Static<\n\tReturnType<typeof EncodedOptionalChangeset<Schema>>\n>;\n\nconst EncodedChildChanges = <Schema extends TSchema>(tNodeChange: Schema) =>\n\tType.Optional(Type.Array(Type.Tuple([EncodedRegisterId, tNodeChange])));\n\n// A list of triplets (source, destination, isNodeTargeting) each representing a move of a node\n// from its current source register to a new destination register.\n// If the move is node targeting then the intention is to move a specific node which happens to be in the source register.\n// Otherwise the intention is to move whatever node happens to be in the source register.\nconst EncodedMoves = Type.Optional(\n\tType.Array(Type.Tuple([EncodedRegisterId, EncodedRegisterId, Type.Optional(Type.Boolean())])),\n);\n"]}

package/dist/simple-tree/flexNode.d.ts

@@ -1,35 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { FlexObjectNodeSchema, FlexFieldNodeSchema, FlexMapNodeSchema, FlexTreeNode, FlexTreeObjectNode, FlexTreeFieldNode, FlexTreeMapNode } from "../feature-libraries/index.js";
-import { TreeNode, TypedNode } from "./types.js";
-import { TreeArrayNode } from "./treeArrayNode.js";
-import { TreeMapNode } from "./schemaTypes.js";
-/**
- * Retrieves the flex node associated with the given target via {@link setFlexNode}.
- * @remarks Fails if the flex node has not been set.
- */
-export declare function getFlexNode(target: TypedNode<FlexObjectNodeSchema>, allowFreed?: true): FlexTreeObjectNode;
-export declare function getFlexNode(target: TreeArrayNode, allowFreed?: true): FlexTreeFieldNode<FlexFieldNodeSchema>;
-export declare function getFlexNode(target: TreeMapNode, allowFreed?: true): FlexTreeMapNode<FlexMapNodeSchema>;
-export declare function getFlexNode(target: TreeNode, allowFreed?: true): FlexTreeNode;
-/**
- * Retrieves the flex node associated with the given target via {@link setFlexNode}, if any.
- */
-export declare function tryGetFlexNode(target: unknown): FlexTreeNode | undefined;
-/**
- * Retrieves the target associated with the given flex node via {@link setFlexNode}, if any.
- */
-export declare function tryGetFlexNodeTarget(flexNode: FlexTreeNode): TreeNode | undefined;
-/**
- * Associate the given target object and the given flex node.
- * @returns The target object
- * @remarks
- * This creates a 1:1 mapping between the target and tree node.
- * Either can be retrieved from the other via {@link getFlexNode}/{@link tryGetFlexNode} or {@link tryGetFlexNodeTarget}.
- * If the given target is already mapped to an flex node, the existing mapping will be overwritten.
- * If the given flex node is already mapped to a different target, this function will fail.
- */
-export declare function setFlexNode<T extends TreeNode>(target: T, flexNode: FlexTreeNode): T;
-//# sourceMappingURL=flexNode.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"flexNode.d.ts","sourceRoot":"","sources":["../../src/simple-tree/flexNode.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EACN,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EAEf,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAiB/C;;;GAGG;AACH,wBAAgB,WAAW,CAC1B,MAAM,EAAE,SAAS,CAAC,oBAAoB,CAAC,EACvC,UAAU,CAAC,EAAE,IAAI,GACf,kBAAkB,CAAC;AACtB,wBAAgB,WAAW,CAC1B,MAAM,EAAE,aAAa,EACrB,UAAU,CAAC,EAAE,IAAI,GACf,iBAAiB,CAAC,mBAAmB,CAAC,CAAC;AAC1C,wBAAgB,WAAW,CAC1B,MAAM,EAAE,WAAW,EACnB,UAAU,CAAC,EAAE,IAAI,GACf,eAAe,CAAC,iBAAiB,CAAC,CAAC;AACtC,wBAAgB,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE,IAAI,GAAG,YAAY,CAAC;AAS/E;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAIxE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,YAAY,GAAG,QAAQ,GAAG,SAAS,CAEjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,QAAQ,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,YAAY,GAAG,CAAC,CASpF"}

package/dist/simple-tree/flexNode.js

@@ -1,62 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setFlexNode = exports.tryGetFlexNodeTarget = exports.tryGetFlexNode = exports.getFlexNode = void 0;
-const core_utils_1 = require("@fluidframework/core-utils");
-const index_js_1 = require("../util/index.js");
-const index_js_2 = require("../feature-libraries/index.js");
-const rawNode_js_1 = require("./rawNode.js");
-/** Associates an FlexTreeNode with a target object  */
-const targetSymbol = Symbol("FlexNodeTarget");
-/**
- * This is intentionally a WeakMap, rather than a private symbol (e.g. like `targetSymbol`).
- * The map behaves essentially the same, except that performing a lookup in the map will not perform a property read/get on the key object (as is the case with a symbol).
- * Since `SharedTreeNodes` are proxies with non-trivial `get` traps, this choice is meant to prevent the confusion of the lookup passing through multiple objects
- * via the trap, or the trap not properly handling the special symbol, etc.
- */
-const flexNodeMap = new WeakMap();
-function getFlexNode(target, allowFreed = false) {
-    const node = flexNodeMap.get(target) ?? (0, index_js_1.fail)("Target is not associated with a flex node");
-    if (!(node instanceof rawNode_js_1.RawTreeNode) && !allowFreed) {
-        (0, index_js_2.assertFlexTreeEntityNotFreed)(node);
-    }
-    return node;
-}
-exports.getFlexNode = getFlexNode;
-/**
- * Retrieves the flex node associated with the given target via {@link setFlexNode}, if any.
- */
-function tryGetFlexNode(target) {
-    // Calling 'WeakMap.get()' with primitives (numbers, strings, etc.) will return undefined.
-    // This is in contrast to 'WeakMap.set()', which will throw a TypeError if given a non-object key.
-    return flexNodeMap.get(target);
-}
-exports.tryGetFlexNode = tryGetFlexNode;
-/**
- * Retrieves the target associated with the given flex node via {@link setFlexNode}, if any.
- */
-function tryGetFlexNodeTarget(flexNode) {
-    return flexNode[targetSymbol];
-}
-exports.tryGetFlexNodeTarget = tryGetFlexNodeTarget;
-/**
- * Associate the given target object and the given flex node.
- * @returns The target object
- * @remarks
- * This creates a 1:1 mapping between the target and tree node.
- * Either can be retrieved from the other via {@link getFlexNode}/{@link tryGetFlexNode} or {@link tryGetFlexNodeTarget}.
- * If the given target is already mapped to an flex node, the existing mapping will be overwritten.
- * If the given flex node is already mapped to a different target, this function will fail.
- */
-function setFlexNode(target, flexNode) {
-    (0, core_utils_1.assert)(tryGetFlexNodeTarget(flexNode) === undefined, 0x7f5 /* Cannot associate an flex node with multiple targets */);
-    delete flexNodeMap.get(target)?.[targetSymbol];
-    flexNodeMap.set(target, flexNode);
-    Object.defineProperty(flexNode, targetSymbol, { value: target, configurable: true });
-    return target;
-}
-exports.setFlexNode = setFlexNode;
-//# sourceMappingURL=flexNode.js.map

package/dist/simple-tree/flexNode.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flexNode.js","sourceRoot":"","sources":["../../src/simple-tree/flexNode.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,2DAAoD;AACpD,+CAAwC;AACxC,4DASuC;AAIvC,6CAA2C;AAE3C,uDAAuD;AACvD,MAAM,YAAY,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;AAK9C;;;;;GAKG;AACH,MAAM,WAAW,GAAG,IAAI,OAAO,EAA0B,CAAC;AAmB1D,SAAgB,WAAW,CAAC,MAAgB,EAAE,UAAU,GAAG,KAAK;IAC/D,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,IAAA,eAAI,EAAC,2CAA2C,CAAC,CAAC;IAC1F,IAAI,CAAC,CAAC,IAAI,YAAY,wBAAW,CAAC,IAAI,CAAC,UAAU,EAAE;QAClD,IAAA,uCAA4B,EAAC,IAAI,CAAC,CAAC;KACnC;IACD,OAAO,IAAI,CAAC;AACb,CAAC;AAND,kCAMC;AAED;;GAEG;AACH,SAAgB,cAAc,CAAC,MAAe;IAC7C,0FAA0F;IAC1F,kGAAkG;IAClG,OAAO,WAAW,CAAC,GAAG,CAAC,MAAkB,CAAC,CAAC;AAC5C,CAAC;AAJD,wCAIC;AAED;;GAEG;AACH,SAAgB,oBAAoB,CAAC,QAAsB;IAC1D,OAAQ,QAA+B,CAAC,YAAY,CAAC,CAAC;AACvD,CAAC;AAFD,oDAEC;AAED;;;;;;;;GAQG;AACH,SAAgB,WAAW,CAAqB,MAAS,EAAE,QAAsB;IAChF,IAAA,mBAAM,EACL,oBAAoB,CAAC,QAAQ,CAAC,KAAK,SAAS,EAC5C,KAAK,CAAC,yDAAyD,CAC/D,CAAC;IACF,OAAQ,WAAW,CAAC,GAAG,CAAC,MAAM,CAAwB,EAAE,CAAC,YAAY,CAAC,CAAC;IACvE,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAClC,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;IACrF,OAAO,MAAM,CAAC;AACf,CAAC;AATD,kCASC","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\";\nimport { fail } from \"../util/index.js\";\nimport {\n\tFlexObjectNodeSchema,\n\tFlexFieldNodeSchema,\n\tFlexMapNodeSchema,\n\tFlexTreeNode,\n\tFlexTreeObjectNode,\n\tFlexTreeFieldNode,\n\tFlexTreeMapNode,\n\tassertFlexTreeEntityNotFreed,\n} from \"../feature-libraries/index.js\";\nimport { TreeNode, TypedNode } from \"./types.js\";\nimport { TreeArrayNode } from \"./treeArrayNode.js\";\nimport { TreeMapNode } from \"./schemaTypes.js\";\nimport { RawTreeNode } from \"./rawNode.js\";\n\n/** Associates an FlexTreeNode with a target object  */\nconst targetSymbol = Symbol(\"FlexNodeTarget\");\ninterface HasTarget {\n\t[targetSymbol]: TreeNode;\n}\n\n/**\n * This is intentionally a WeakMap, rather than a private symbol (e.g. like `targetSymbol`).\n * The map behaves essentially the same, except that performing a lookup in the map will not perform a property read/get on the key object (as is the case with a symbol).\n * Since `SharedTreeNodes` are proxies with non-trivial `get` traps, this choice is meant to prevent the confusion of the lookup passing through multiple objects\n * via the trap, or the trap not properly handling the special symbol, etc.\n */\nconst flexNodeMap = new WeakMap<TreeNode, FlexTreeNode>();\n\n/**\n * Retrieves the flex node associated with the given target via {@link setFlexNode}.\n * @remarks Fails if the flex node has not been set.\n */\nexport function getFlexNode(\n\ttarget: TypedNode<FlexObjectNodeSchema>,\n\tallowFreed?: true,\n): FlexTreeObjectNode;\nexport function getFlexNode(\n\ttarget: TreeArrayNode,\n\tallowFreed?: true,\n): FlexTreeFieldNode<FlexFieldNodeSchema>;\nexport function getFlexNode(\n\ttarget: TreeMapNode,\n\tallowFreed?: true,\n): FlexTreeMapNode<FlexMapNodeSchema>;\nexport function getFlexNode(target: TreeNode, allowFreed?: true): FlexTreeNode;\nexport function getFlexNode(target: TreeNode, allowFreed = false): FlexTreeNode {\n\tconst node = flexNodeMap.get(target) ?? fail(\"Target is not associated with a flex node\");\n\tif (!(node instanceof RawTreeNode) && !allowFreed) {\n\t\tassertFlexTreeEntityNotFreed(node);\n\t}\n\treturn node;\n}\n\n/**\n * Retrieves the flex node associated with the given target via {@link setFlexNode}, if any.\n */\nexport function tryGetFlexNode(target: unknown): FlexTreeNode | undefined {\n\t// Calling 'WeakMap.get()' with primitives (numbers, strings, etc.) will return undefined.\n\t// This is in contrast to 'WeakMap.set()', which will throw a TypeError if given a non-object key.\n\treturn flexNodeMap.get(target as TreeNode);\n}\n\n/**\n * Retrieves the target associated with the given flex node via {@link setFlexNode}, if any.\n */\nexport function tryGetFlexNodeTarget(flexNode: FlexTreeNode): TreeNode | undefined {\n\treturn (flexNode as Partial<HasTarget>)[targetSymbol];\n}\n\n/**\n * Associate the given target object and the given flex node.\n * @returns The target object\n * @remarks\n * This creates a 1:1 mapping between the target and tree node.\n * Either can be retrieved from the other via {@link getFlexNode}/{@link tryGetFlexNode} or {@link tryGetFlexNodeTarget}.\n * If the given target is already mapped to an flex node, the existing mapping will be overwritten.\n * If the given flex node is already mapped to a different target, this function will fail.\n */\nexport function setFlexNode<T extends TreeNode>(target: T, flexNode: FlexTreeNode): T {\n\tassert(\n\t\ttryGetFlexNodeTarget(flexNode) === undefined,\n\t\t0x7f5 /* Cannot associate an flex node with multiple targets */,\n\t);\n\tdelete (flexNodeMap.get(target) as Partial<HasTarget>)?.[targetSymbol];\n\tflexNodeMap.set(target, flexNode);\n\tObject.defineProperty(flexNode, targetSymbol, { value: target, configurable: true });\n\treturn target;\n}\n"]}

package/dist/simple-tree/treeArrayNode.d.ts

@@ -1,46 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { TreeArrayNodeBase, TreeNode } from "./types.js";
-import { type ImplicitAllowedTypes, type TreeNodeFromImplicitAllowedTypes, type InsertableTreeNodeFromImplicitAllowedTypes } from "./schemaTypes.js";
-/**
- * A {@link TreeNode} which implements 'readonly T[]' and the array mutation APIs.
- *
- * @typeParam TAllowedTypes - Schema for types which are allowed as members of this array.
- *
- * @public
- */
-export interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes> extends TreeNode, TreeArrayNodeBase<TreeNodeFromImplicitAllowedTypes<TAllowedTypes>, InsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>, TreeArrayNode> {
-}
-/**
- * A {@link TreeNode} which implements 'readonly T[]' and the array mutation APIs.
- * @public
- */
-export declare const TreeArrayNode: {
-    /**
-     * Wrap an iterable of items to inserted as consecutive items in a array.
-     * @remarks
-     * The object returned by this function can be inserted into a {@link (TreeArrayNode:interface)}.
-     * Its contents will be inserted consecutively in the corresponding location in the array.
-     * @example
-     * ```ts
-     * array.insertAtEnd(TreeArrayNode.spread(iterable))
-     * ```
-     */
-    spread: <T>(content: Iterable<T>) => IterableTreeArrayContent<T>;
-};
-/**
- * Used to insert iterable content into a {@link (TreeArrayNode:interface)}.
- * Use {@link (TreeArrayNode:variable).spread} to create an instance of this type.
- * @public
- */
-export declare class IterableTreeArrayContent<T> implements Iterable<T> {
-    private readonly content;
-    private constructor();
-    /**
-     * Iterates over content for nodes to insert.
-     */
-    [Symbol.iterator](): Iterator<T>;
-}
-//# sourceMappingURL=treeArrayNode.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"treeArrayNode.d.ts","sourceRoot":"","sources":["../../src/simple-tree/treeArrayNode.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,gCAAgC,EACrC,KAAK,0CAA0C,EAC/C,MAAM,kBAAkB,CAAC;AAE1B;;;;;;GAMG;AACH,MAAM,WAAW,aAAa,CAAC,aAAa,SAAS,oBAAoB,GAAG,oBAAoB,CAC/F,SAAQ,QAAQ,EACf,iBAAiB,CAChB,gCAAgC,CAAC,aAAa,CAAC,EAC/C,0CAA0C,CAAC,aAAa,CAAC,EACzD,aAAa,CACb;CAAG;AAEN;;;GAGG;AACH,eAAO,MAAM,aAAa;IACzB;;;;;;;;;OASG;;CAEH,CAAC;AAQF;;;;GAIG;AACH,qBAAa,wBAAwB,CAAC,CAAC,CAAE,YAAW,QAAQ,CAAC,CAAC,CAAC;IAK1C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAA5C,OAAO;IAEP;;OAEG;IACI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC;CAGvC"}

package/dist/simple-tree/treeArrayNode.js

@@ -1,50 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IterableTreeArrayContent = exports.TreeArrayNode = void 0;
-/**
- * A {@link TreeNode} which implements 'readonly T[]' and the array mutation APIs.
- * @public
- */
-exports.TreeArrayNode = {
-    /**
-     * Wrap an iterable of items to inserted as consecutive items in a array.
-     * @remarks
-     * The object returned by this function can be inserted into a {@link (TreeArrayNode:interface)}.
-     * Its contents will be inserted consecutively in the corresponding location in the array.
-     * @example
-     * ```ts
-     * array.insertAtEnd(TreeArrayNode.spread(iterable))
-     * ```
-     */
-    spread: (content) => create(content),
-};
-/**
- * Package internal construction API.
- * Use {@link (TreeArrayNode:variable).spread} to create an instance of this type instead.
- */
-let create;
-/**
- * Used to insert iterable content into a {@link (TreeArrayNode:interface)}.
- * Use {@link (TreeArrayNode:variable).spread} to create an instance of this type.
- * @public
- */
-class IterableTreeArrayContent {
-    constructor(content) {
-        this.content = content;
-    }
-    /**
-     * Iterates over content for nodes to insert.
-     */
-    [Symbol.iterator]() {
-        return this.content[Symbol.iterator]();
-    }
-}
-exports.IterableTreeArrayContent = IterableTreeArrayContent;
-(() => {
-    create = (content) => new IterableTreeArrayContent(content);
-})();
-//# sourceMappingURL=treeArrayNode.js.map

package/dist/simple-tree/treeArrayNode.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"treeArrayNode.js","sourceRoot":"","sources":["../../src/simple-tree/treeArrayNode.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAwBH;;;GAGG;AACU,QAAA,aAAa,GAAG;IAC5B;;;;;;;;;OASG;IACH,MAAM,EAAE,CAAI,OAAoB,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC;CACpD,CAAC;AAEF;;;GAGG;AACH,IAAI,MAAgE,CAAC;AAErE;;;;GAIG;AACH,MAAa,wBAAwB;IAKpC,YAAqC,OAAoB;QAApB,YAAO,GAAP,OAAO,CAAa;IAAG,CAAC;IAE7D;;OAEG;IACI,CAAC,MAAM,CAAC,QAAQ,CAAC;QACvB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IACxC,CAAC;CACD;AAbD,4DAaC;AAZA;IACC,MAAM,GAAG,CAAK,OAAqB,EAAE,EAAE,CAAC,IAAI,wBAAwB,CAAC,OAAO,CAAC,CAAC;AAC/E,CAAC,GAAA,CAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { TreeArrayNodeBase, TreeNode } from \"./types.js\";\nimport {\n\ttype ImplicitAllowedTypes,\n\ttype TreeNodeFromImplicitAllowedTypes,\n\ttype InsertableTreeNodeFromImplicitAllowedTypes,\n} from \"./schemaTypes.js\";\n\n/**\n * A {@link TreeNode} which implements 'readonly T[]' and the array mutation APIs.\n *\n * @typeParam TAllowedTypes - Schema for types which are allowed as members of this array.\n *\n * @public\n */\nexport interface TreeArrayNode<TAllowedTypes extends ImplicitAllowedTypes = ImplicitAllowedTypes>\n\textends TreeNode,\n\t\tTreeArrayNodeBase<\n\t\t\tTreeNodeFromImplicitAllowedTypes<TAllowedTypes>,\n\t\t\tInsertableTreeNodeFromImplicitAllowedTypes<TAllowedTypes>,\n\t\t\tTreeArrayNode\n\t\t> {}\n\n/**\n * A {@link TreeNode} which implements 'readonly T[]' and the array mutation APIs.\n * @public\n */\nexport const TreeArrayNode = {\n\t/**\n\t * Wrap an iterable of items to inserted as consecutive items in a array.\n\t * @remarks\n\t * The object returned by this function can be inserted into a {@link (TreeArrayNode:interface)}.\n\t * Its contents will be inserted consecutively in the corresponding location in the array.\n\t * @example\n\t * ```ts\n\t * array.insertAtEnd(TreeArrayNode.spread(iterable))\n\t * ```\n\t */\n\tspread: <T>(content: Iterable<T>) => create(content),\n};\n\n/**\n * Package internal construction API.\n * Use {@link (TreeArrayNode:variable).spread} to create an instance of this type instead.\n */\nlet create: <T>(content: Iterable<T>) => IterableTreeArrayContent<T>;\n\n/**\n * Used to insert iterable content into a {@link (TreeArrayNode:interface)}.\n * Use {@link (TreeArrayNode:variable).spread} to create an instance of this type.\n * @public\n */\nexport class IterableTreeArrayContent<T> implements Iterable<T> {\n\tstatic {\n\t\tcreate = <T2>(content: Iterable<T2>) => new IterableTreeArrayContent(content);\n\t}\n\n\tprivate constructor(private readonly content: Iterable<T>) {}\n\n\t/**\n\t * Iterates over content for nodes to insert.\n\t */\n\tpublic [Symbol.iterator](): Iterator<T> {\n\t\treturn this.content[Symbol.iterator]();\n\t}\n}\n"]}