@fluidframework/tree 2.90.0-378676 → 2.91.0

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

@@ -1 +1 @@
-{"version":3,"file":"unhydratedFlexTreeFromInsertable.js","sourceRoot":"","sources":["../../src/simple-tree/unhydratedFlexTreeFromInsertable.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 type { IFluidHandle } from \"@fluidframework/core-interfaces\";\nimport { assert, debugAssert, fail } from \"@fluidframework/core-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport type { FlexTreeNode } from \"../feature-libraries/index.js\";\nimport { filterIterable, hasSingle, oneFromIterable } from \"../util/index.js\";\n\nimport {\n\tCompatibilityLevel,\n\tgetKernel,\n\tgetTreeNodeSchemaPrivateData,\n\tisTreeNode,\n\ttype TreeNode,\n\ttype TreeNodeSchema,\n\tcontentSchemaSymbol,\n\ttype Unhydrated,\n\tUnhydratedFlexTreeNode,\n} from \"./core/index.js\";\nimport { getUnhydratedContext } from \"./createContext.js\";\nimport { normalizeFieldSchema, FieldKind, type ImplicitFieldSchema } from \"./fieldSchema.js\";\n\n/**\n * Transforms an input {@link TypedNode} tree to a {@link FlexTreeNode}.\n * @param data - The input tree to be converted.\n * If the data is an unsupported value (e.g. NaN), a fallback value will be used when supported,\n * otherwise an error will be thrown.\n *\n * Fallbacks:\n *\n * * `NaN` =\\> `null`\n *\n * * `+/-∞` =\\> `null`\n *\n * * `-0` =\\> `+0`\n *\n * For fields with a default value, the field may be omitted.\n * If `context` is not provided, defaults which require a context will be left empty which can be out of schema.\n *\n * @param allowedTypes - The set of types allowed by the parent context. Used to validate the input tree.\n * @remarks\n * The resulting tree will be populated with any defaults from {@link FieldProvider}s in the schema.\n *\n * Often throws UsageErrors for invalid data, but may miss some cases.\n *\n * Output should comply with the provided view schema, but this is not explicitly validated:\n * validation against stored schema (to guard against document corruption) is done elsewhere.\n */\nexport function flexTreeFromInsertable<TIn extends InsertableContent | undefined>(\n\tdata: TIn,\n\tallowedTypes: ImplicitFieldSchema,\n): TIn extends undefined ? undefined : FlexTreeNode {\n\tconst normalizedFieldSchema = normalizeFieldSchema(allowedTypes);\n\n\tif (data === undefined) {\n\t\t// TODO: this code-path should support defaults\n\t\tif (normalizedFieldSchema.kind !== FieldKind.Optional) {\n\t\t\tthrow new UsageError(\n\t\t\t\t`Got undefined for non-optional field expecting one of ${quotedAllowedTypesWithNames(normalizedFieldSchema.allowedTypeSet)}`,\n\t\t\t);\n\t\t}\n\t\treturn undefined as TIn extends undefined ? undefined : FlexTreeNode;\n\t}\n\n\tconst flexTree: FlexTreeNode = flexTreeFromInsertableNode(\n\t\tdata,\n\t\tnormalizedFieldSchema.allowedTypeSet,\n\t);\n\n\treturn flexTree as TIn extends undefined ? undefined : FlexTreeNode;\n}\n\n/**\n * Throw a usage error with a helpful message about `schema` not being in `allowedTypes` for insertable content.\n */\nfunction allowedTypesInsertableSchemaError(\n\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n\tschema: TreeNodeSchema,\n): never {\n\tdebugAssert(\n\t\t() =>\n\t\t\t!allowedTypes.has(schema) ||\n\t\t\t\"This function should only be called if the schema is not in the allowed types.\",\n\t);\n\tconst map = new Map([...allowedTypes].map((s) => [s.identifier, s]));\n\tconst expected = map.get(schema.identifier);\n\tif (expected !== undefined) {\n\t\tthrow new UsageError(\n\t\t\t`A node with schema ${quotedSchemaIdentifierWithName(schema)} was provided where a node with that identifier is allowed, but the actual schema required (${quotedSchemaIdentifierWithName(expected)}) is not the same schema object.\nTreeNodeSchema have significant object identity and thus the exact same object must be used as the schema when defining what nodes are allowed and when constructing the node to use.`,\n\t\t);\n\t}\n\tthrow new UsageError(\n\t\t`Expected insertable for one of ${quotedAllowedTypesWithNames(allowedTypes)}. Got node with schema ${quotedSchemaIdentifierWithName(schema)}.\nNodes are valid insertable objects, but only if their schema are in the allowed list.`,\n\t);\n}\n\n/**\n * Gets a description of a schema for use in error messages.\n */\nfunction quotedSchemaIdentifierWithName(schema: TreeNodeSchema): string {\n\t// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n\treturn `${JSON.stringify(schema.identifier)} (name: ${JSON.stringify((schema as Function).name)})`;\n}\n\n/**\n * Gets a description of an allowedTypes for use in error messages.\n */\nfunction quotedAllowedTypesWithNames(allowedTypes: Iterable<TreeNodeSchema>): string {\n\treturn `[${[...allowedTypes].map(quotedSchemaIdentifierWithName).join(\", \")}]`;\n}\n\n/**\n * Copy content from `data` into a UnhydratedFlexTreeNode.\n */\nexport function unhydratedFlexTreeFromInsertable<TIn extends InsertableContent | undefined>(\n\tdata: TIn,\n\tallowedTypes: ImplicitFieldSchema,\n): TIn extends undefined ? undefined : UnhydratedFlexTreeNode {\n\tconst result = flexTreeFromInsertable(data, allowedTypes);\n\tif (result === undefined) {\n\t\treturn undefined as TIn extends undefined ? undefined : UnhydratedFlexTreeNode;\n\t}\n\tassert(result instanceof UnhydratedFlexTreeNode, \"expected unhydrated node\");\n\treturn result as TIn extends undefined ? undefined : UnhydratedFlexTreeNode;\n}\n\n/**\n * Copy content from `data` into a UnhydratedFlexTreeNode or return an existing node if `data` is a TreeNode.\n */\nexport function flexTreeFromInsertableNode(\n\tdata: InsertableContent,\n\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n): FlexTreeNode {\n\tif (isTreeNode(data)) {\n\t\tconst kernel = getKernel(data);\n\t\tconst inner = kernel.getInnerNode();\n\t\tif (inner.parentField.parent.parent === undefined) {\n\t\t\tif (!allowedTypes.has(kernel.schema)) {\n\t\t\t\tallowedTypesInsertableSchemaError(allowedTypes, kernel.schema);\n\t\t\t}\n\n\t\t\tif (inner.isHydrated()) {\n\t\t\t\t// TODO: hook up event bubbling from hydrated to unhydrated tree.\n\t\t\t}\n\n\t\t\treturn inner;\n\t\t} else {\n\t\t\tthrow new UsageError(\n\t\t\t\t\"A node which already has a parent may not be used as part of a new tree.\",\n\t\t\t);\n\t\t}\n\t}\n\n\tconst schema = getType(data, allowedTypes);\n\tconst handler = getTreeNodeSchemaPrivateData(schema).idempotentInitialize();\n\tconst result = handler.toFlexContent(data, allowedTypes);\n\n\t// Might not match schema due to fallbacks, see TODO on toFlexContent\n\t// TODO: fix TODO in `toFlexContent`, and remove this.\n\tconst finalSchema =\n\t\toneFromIterable(filterIterable(allowedTypes, (s) => s.identifier === result[0].type)) ??\n\t\tfail(0xc9d /* missing schema */);\n\n\treturn new UnhydratedFlexTreeNode(...result, getUnhydratedContext(finalSchema));\n}\n\nfunction getType(\n\tdata: FactoryContent,\n\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n): TreeNodeSchema {\n\tconst possibleTypes = getPossibleTypes(allowedTypes, data);\n\tif (possibleTypes.length === 0) {\n\t\tthrow new UsageError(\n\t\t\t`The provided data is incompatible with all of the types allowed by the schema. The set of allowed types is: ${quotedAllowedTypesWithNames(allowedTypes)}.`,\n\t\t);\n\t}\n\tif (!hasSingle(possibleTypes)) {\n\t\tthrow new UsageError(\n\t\t\t`The provided data is compatible with more than one type allowed by the schema.\nThe set of possible types is ${quotedAllowedTypesWithNames(possibleTypes)}.\nExplicitly construct an unhydrated node of the desired type to disambiguate.\nFor class-based schema, this can be done by replacing an expression like \"{foo: 1}\" with \"new MySchema({foo: 1})\".`,\n\t\t);\n\t}\n\treturn possibleTypes[0];\n}\n\n/**\n * Returns all types for which the data is schema-compatible.\n * @remarks This will respect the {@link contentSchemaSymbol} property on data to disambiguate types - if present, only that type will be returned.\n */\nexport function getPossibleTypes(\n\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n\tdata: FactoryContent,\n): TreeNodeSchema[] {\n\tassert(data !== undefined, 0x889 /* undefined cannot be used as FactoryContent. */);\n\n\tlet toCheck: Iterable<TreeNodeSchema>;\n\tif (typeof data === \"object\" && data !== null && contentSchemaSymbol in data) {\n\t\t// If the data has an explicit brand via contentSchemaSymbol, only check that type.\n\t\tconst type = data[contentSchemaSymbol];\n\t\ttoCheck = filterIterable(allowedTypes, (schema) => schema.identifier === type);\n\t} else {\n\t\ttoCheck = allowedTypes;\n\t}\n\n\t// Start at the lowest level of compat we would ever accept: this discards types which are less compatible.\n\tlet best = CompatibilityLevel.Low;\n\tconst possibleTypes: TreeNodeSchema[] = [];\n\tfor (const schema of toCheck) {\n\t\tconst handler = getTreeNodeSchemaPrivateData(schema).idempotentInitialize();\n\t\tconst level = handler.shallowCompatibilityTest(data);\n\t\tif (level > best) {\n\t\t\tpossibleTypes.length = 0;\n\t\t\tbest = level;\n\t\t}\n\t\tif (best === level) {\n\t\t\tpossibleTypes.push(schema);\n\t\t}\n\t}\n\treturn possibleTypes;\n}\n\n/**\n * Content which can be used to build a node.\n * @remarks\n * Can contain unhydrated nodes, but can not be an unhydrated node at the root.\n * @system @alpha\n */\nexport type FactoryContent =\n\t| IFluidHandle\n\t| string\n\t| number\n\t| boolean\n\t// eslint-disable-next-line @rushstack/no-new-null\n\t| null\n\t| Iterable<readonly [string, InsertableContent]>\n\t| readonly InsertableContent[]\n\t| FactoryContentObject;\n\n/**\n * Record-like object which can be used to build some kinds of nodes.\n * @remarks\n * Can contain unhydrated nodes, but can not be an unhydrated node at the root.\n *\n * Supports object and map nodes.\n * @system @alpha\n */\nexport type FactoryContentObject = {\n\treadonly [P in string]?: InsertableContent;\n};\n\n/**\n * Content which can be inserted into a tree.\n * @system @alpha\n */\nexport type InsertableContent = Unhydrated<TreeNode> | FactoryContent;\n"]}
+{"version":3,"file":"unhydratedFlexTreeFromInsertable.js","sourceRoot":"","sources":["../../src/simple-tree/unhydratedFlexTreeFromInsertable.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 type { IFluidHandle } from \"@fluidframework/core-interfaces\";\nimport { assert, debugAssert, fail } from \"@fluidframework/core-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport { filterIterable, hasSingle, oneFromIterable } from \"../util/index.js\";\n\nimport {\n\tCompatibilityLevel,\n\tgetKernel,\n\tgetTreeNodeSchemaPrivateData,\n\tisTreeNode,\n\ttype TreeNode,\n\ttype TreeNodeSchema,\n\tcontentSchemaSymbol,\n\ttype Unhydrated,\n\tUnhydratedFlexTreeNode,\n} from \"./core/index.js\";\nimport { getUnhydratedContext } from \"./createContext.js\";\nimport { normalizeFieldSchema, FieldKind, type ImplicitFieldSchema } from \"./fieldSchema.js\";\n\n/**\n * Transforms an input {@link TypedNode} tree to an {@link UnhydratedFlexTreeNode}.\n * @param data - The input tree to be converted.\n * If the data is an unsupported value (e.g. NaN), a fallback value will be used when supported,\n * otherwise an error will be thrown.\n *\n * Fallbacks:\n *\n * * `NaN` =\\> `null`\n *\n * * `+/-∞` =\\> `null`\n *\n * * `-0` =\\> `+0`\n *\n * For fields with a default value, the field may be omitted.\n * If `context` is not provided, defaults which require a context will be left empty which can be out of schema.\n *\n * @param allowedTypes - The set of types allowed by the parent context. Used to validate the input tree.\n * @remarks\n * The resulting tree will be populated with any defaults from {@link FieldProvider}s in the schema.\n *\n * Often throws UsageErrors for invalid data, but may miss some cases.\n *\n * Output should comply with the provided view schema, but this is not explicitly validated:\n * validation against stored schema (to guard against document corruption) is done elsewhere.\n */\nexport function unhydratedFlexTreeFromInsertable<TIn extends InsertableContent | undefined>(\n\tdata: TIn,\n\tallowedTypes: ImplicitFieldSchema,\n): TIn extends undefined ? undefined : UnhydratedFlexTreeNode {\n\tconst normalizedFieldSchema = normalizeFieldSchema(allowedTypes);\n\n\tif (data === undefined) {\n\t\t// TODO: this code-path should support defaults\n\t\tif (normalizedFieldSchema.kind !== FieldKind.Optional) {\n\t\t\tthrow new UsageError(\n\t\t\t\t`Got undefined for non-optional field expecting one of ${quotedAllowedTypesWithNames(normalizedFieldSchema.allowedTypeSet)}`,\n\t\t\t);\n\t\t}\n\t\treturn undefined as TIn extends undefined ? undefined : UnhydratedFlexTreeNode;\n\t}\n\n\tconst flexTree: UnhydratedFlexTreeNode = unhydratedFlexTreeFromInsertableNode(\n\t\tdata,\n\t\tnormalizedFieldSchema.allowedTypeSet,\n\t);\n\n\treturn flexTree as TIn extends undefined ? undefined : UnhydratedFlexTreeNode;\n}\n\n/**\n * Throw a usage error with a helpful message about `schema` not being in `allowedTypes` for insertable content.\n */\nfunction allowedTypesInsertableSchemaError(\n\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n\tschema: TreeNodeSchema,\n): never {\n\tdebugAssert(\n\t\t() =>\n\t\t\t!allowedTypes.has(schema) ||\n\t\t\t\"This function should only be called if the schema is not in the allowed types.\",\n\t);\n\tconst map = new Map([...allowedTypes].map((s) => [s.identifier, s]));\n\tconst expected = map.get(schema.identifier);\n\tif (expected !== undefined) {\n\t\tthrow new UsageError(\n\t\t\t`A node with schema ${quotedSchemaIdentifierWithName(schema)} was provided where a node with that identifier is allowed, but the actual schema required (${quotedSchemaIdentifierWithName(expected)}) is not the same schema object.\nTreeNodeSchema have significant object identity and thus the exact same object must be used as the schema when defining what nodes are allowed and when constructing the node to use.`,\n\t\t);\n\t}\n\tthrow new UsageError(\n\t\t`Expected insertable for one of ${quotedAllowedTypesWithNames(allowedTypes)}. Got node with schema ${quotedSchemaIdentifierWithName(schema)}.\nNodes are valid insertable objects, but only if their schema are in the allowed list.`,\n\t);\n}\n\n/**\n * Gets a description of a schema for use in error messages.\n */\nfunction quotedSchemaIdentifierWithName(schema: TreeNodeSchema): string {\n\t// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n\treturn `${JSON.stringify(schema.identifier)} (name: ${JSON.stringify((schema as Function).name)})`;\n}\n\n/**\n * Gets a description of an allowedTypes for use in error messages.\n */\nfunction quotedAllowedTypesWithNames(allowedTypes: Iterable<TreeNodeSchema>): string {\n\treturn `[${[...allowedTypes].map(quotedSchemaIdentifierWithName).join(\", \")}]`;\n}\n\n/**\n * Copy content from `data` into a UnhydratedFlexTreeNode.\n */\nexport function unhydratedFlexTreeFromInsertableNode(\n\tdata: InsertableContent,\n\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n): UnhydratedFlexTreeNode {\n\tif (isTreeNode(data)) {\n\t\tconst kernel = getKernel(data);\n\t\tconst inner = kernel.getInnerNodeIfUnhydrated();\n\t\tif (inner === undefined) {\n\t\t\t// The node is already hydrated, meaning that it already got inserted into the tree previously\n\t\t\tthrow new UsageError(\n\t\t\t\t`A node with schema ${quotedSchemaIdentifierWithName(kernel.schema)} was inserted into the tree more than once. This is not supported.`,\n\t\t\t);\n\t\t} else {\n\t\t\tif (!allowedTypes.has(kernel.schema)) {\n\t\t\t\tallowedTypesInsertableSchemaError(allowedTypes, kernel.schema);\n\t\t\t}\n\t\t\treturn inner;\n\t\t}\n\t}\n\n\tconst schema = getType(data, allowedTypes);\n\tconst handler = getTreeNodeSchemaPrivateData(schema).idempotentInitialize();\n\tconst result = handler.toFlexContent(data, allowedTypes);\n\n\t// Might not match schema due to fallbacks, see TODO on toFlexContent\n\t// TODO: fix TODO in `toFlexContent`, and remove this.\n\tconst finalSchema =\n\t\toneFromIterable(filterIterable(allowedTypes, (s) => s.identifier === result[0].type)) ??\n\t\tfail(0xc9d /* missing schema */);\n\n\treturn new UnhydratedFlexTreeNode(...result, getUnhydratedContext(finalSchema));\n}\n\nfunction getType(\n\tdata: FactoryContent,\n\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n): TreeNodeSchema {\n\tconst possibleTypes = getPossibleTypes(allowedTypes, data);\n\tif (possibleTypes.length === 0) {\n\t\tthrow new UsageError(\n\t\t\t`The provided data is incompatible with all of the types allowed by the schema. The set of allowed types is: ${quotedAllowedTypesWithNames(allowedTypes)}.`,\n\t\t);\n\t}\n\tif (!hasSingle(possibleTypes)) {\n\t\tthrow new UsageError(\n\t\t\t`The provided data is compatible with more than one type allowed by the schema.\nThe set of possible types is ${quotedAllowedTypesWithNames(possibleTypes)}.\nExplicitly construct an unhydrated node of the desired type to disambiguate.\nFor class-based schema, this can be done by replacing an expression like \"{foo: 1}\" with \"new MySchema({foo: 1})\".`,\n\t\t);\n\t}\n\treturn possibleTypes[0];\n}\n\n/**\n * Returns all types for which the data is schema-compatible.\n * @remarks This will respect the {@link contentSchemaSymbol} property on data to disambiguate types - if present, only that type will be returned.\n */\nexport function getPossibleTypes(\n\tallowedTypes: ReadonlySet<TreeNodeSchema>,\n\tdata: FactoryContent,\n): TreeNodeSchema[] {\n\tassert(data !== undefined, 0x889 /* undefined cannot be used as FactoryContent. */);\n\n\tlet toCheck: Iterable<TreeNodeSchema>;\n\tif (typeof data === \"object\" && data !== null && contentSchemaSymbol in data) {\n\t\t// If the data has an explicit brand via contentSchemaSymbol, only check that type.\n\t\tconst type = data[contentSchemaSymbol];\n\t\ttoCheck = filterIterable(allowedTypes, (schema) => schema.identifier === type);\n\t} else {\n\t\ttoCheck = allowedTypes;\n\t}\n\n\t// Start at the lowest level of compat we would ever accept: this discards types which are less compatible.\n\tlet best = CompatibilityLevel.Low;\n\tconst possibleTypes: TreeNodeSchema[] = [];\n\tfor (const schema of toCheck) {\n\t\tconst handler = getTreeNodeSchemaPrivateData(schema).idempotentInitialize();\n\t\tconst level = handler.shallowCompatibilityTest(data);\n\t\tif (level > best) {\n\t\t\tpossibleTypes.length = 0;\n\t\t\tbest = level;\n\t\t}\n\t\tif (best === level) {\n\t\t\tpossibleTypes.push(schema);\n\t\t}\n\t}\n\treturn possibleTypes;\n}\n\n/**\n * Content which can be used to build a node.\n * @remarks\n * Can contain unhydrated nodes, but can not be an unhydrated node at the root.\n * @system @alpha\n */\nexport type FactoryContent =\n\t| IFluidHandle\n\t| string\n\t| number\n\t| boolean\n\t// eslint-disable-next-line @rushstack/no-new-null\n\t| null\n\t| Iterable<readonly [string, InsertableContent]>\n\t| readonly InsertableContent[]\n\t| FactoryContentObject;\n\n/**\n * Record-like object which can be used to build some kinds of nodes.\n * @remarks\n * Can contain unhydrated nodes, but can not be an unhydrated node at the root.\n *\n * Supports object and map nodes.\n * @system @alpha\n */\nexport type FactoryContentObject = {\n\treadonly [P in string]?: InsertableContent;\n};\n\n/**\n * Content which can be inserted into a tree.\n * @system @alpha\n */\nexport type InsertableContent = Unhydrated<TreeNode> | FactoryContent;\n"]}

package/lib/text/textDomain.d.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 import type { TreeNode, WithType } from "../simple-tree/index.js";
+import type { NodeKind, TreeNodeSchema } from "../simple-tree/index.js";
 /**
  * Interpret a string as an iterable of characters.
  * @remarks
@@ -71,12 +72,12 @@ export declare function charactersFromString(value: string): Iterable<string>;
  *
  * Part of that work will be establishing and documenting those patterns so other components with complex encodings can follow them,
  * in addition to implementing them for text.
- * @internal
+ * @alpha
  */
 export declare namespace TextAsTree {
     /**
      * Statics for text nodes.
-     * @internal
+     * @alpha
      */
     interface Statics {
         /**
@@ -100,7 +101,7 @@ export declare namespace TextAsTree {
      *
      * @see {@link TextAsTree.Statics.fromString} for construction.
      * @see {@link TextAsTree.(Tree:type)} for schema.
-     * @internal
+     * @alpha
      */
     interface Members {
         /**
@@ -109,6 +110,18 @@ export declare namespace TextAsTree {
          * This iterator matches the behavior of {@link (TreeArrayNode:interface)} with respect to edits during iteration.
          */
         characters(): Iterable<string>;
+        /**
+         * Optimized way to get a copy of the {@link TextAsTree.Members.characters} in an array.
+         */
+        charactersCopy(): string[];
+        /**
+         * Gets the number of characters currently in the text.
+         * @remarks
+         * The length of {@link TextAsTree.Members.characters}.
+         * This is not the length of the string returned by {@link TextAsTree.Members.fullString},
+         * as that string may contain characters which are made up of multiple UTF-16 code units.
+         */
+        characterCount(): number;
         /**
          * Copy the content of this node into a string.
          */
@@ -131,16 +144,21 @@ export declare namespace TextAsTree {
          * Remove a range from a string based on character index.
          * See {@link (TreeArrayNode:interface).removeRange} for more details on the behavior.
          */
-        removeRange(index: number, length: number): void;
+        removeRange(startIndex: number | undefined, endIndex: number | undefined): void;
     }
     /**
-     * Schema for a text node.
+     * Schema for a {@link TextAsTree.(Tree:variable)} node.
+     * @remarks
+     * See {@link TextAsTree.Statics} for static APIs on this schema, including construction.
+     * @alpha
+     */
+    const Tree: Statics & TreeNodeSchema<"com.fluidframework.text.Text", NodeKind, Members & TreeNode & WithType<"com.fluidframework.text.Text", NodeKind, unknown>, never, false>;
+    /**
+     * Node for the {@link TextAsTree.(Tree:type)} schema exposing the {@link TextAsTree.Members} API.
      * @remarks
-     * See {@link TextAsTree.Members} for the API.
-     * See {@link TextAsTree.Statics} for static APIs on this Schema, including construction.
-     * @internal
+     * Create using {@link TextAsTree.Statics.fromString}.
+     * @alpha
      */
-    const Tree: Statics & import("../simple-tree/index.js").TreeNodeSchema<"com.fluidframework.text.Text", import("../simple-tree/index.js").NodeKind, Members & TreeNode & WithType<"com.fluidframework.text.Text", import("../simple-tree/index.js").NodeKind, unknown>, never, false>;
     type Tree = Members & TreeNode & WithType<"com.fluidframework.text.Text">;
 }
 //# sourceMappingURL=textDomain.d.ts.map

package/lib/text/textDomain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"textDomain.d.ts","sourceRoot":"","sources":["../../src/text/textDomain.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAkClE;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,CAKpE;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,yBAAiB,UAAU,CAAC;IAC3B;;;OAGG;IACH,UAAiB,OAAO;QACvB;;;WAGG;QACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;KAChC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,UAAiB,OAAO;QACvB;;;;WAIG;QACH,UAAU,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;QAE/B;;WAEG;QACH,UAAU,IAAI,MAAM,CAAC;QAErB;;;;;;;;;;;;WAYG;QACH,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;QAE5D;;;WAGG;QACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;KACjD;IAED;;;;;;OAMG;IACI,MAAM,IAAI,0QAAmD,CAAC;IACrE,KAAY,IAAI,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC,8BAA8B,CAAC,CAAC;CACjF"}
+{"version":3,"file":"textDomain.d.ts","sourceRoot":"","sources":["../../src/text/textDomain.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAaH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAIlE,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAmExE;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,CAKpE;AAsBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,yBAAiB,UAAU,CAAC;IAC3B;;;OAGG;IACH,UAAiB,OAAO;QACvB;;;WAGG;QACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;KAChC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,UAAiB,OAAO;QACvB;;;;WAIG;QACH,UAAU,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;QAE/B;;WAEG;QACH,cAAc,IAAI,MAAM,EAAE,CAAC;QAE3B;;;;;;WAMG;QACH,cAAc,IAAI,MAAM,CAAC;QAEzB;;WAEG;QACH,UAAU,IAAI,MAAM,CAAC;QAErB;;;;;;;;;;;;WAYG;QACH,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;QAE5D;;;WAGG;QACH,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;KAChF;IAED;;;;;OAKG;IACI,MAAM,IAAI,oKAAmD,CAAC;IAErE;;;;;OAKG;IACH,KAAY,IAAI,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC,8BAA8B,CAAC,CAAC;CACjF"}

package/lib/text/textDomain.js

@@ -2,8 +2,9 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { EmptyKey } from "../core/index.js";
-import { eraseSchemaDetails, SchemaFactory, SchemaFactoryAlpha, TreeArrayNode, } from "../simple-tree/index.js";
+import { compareArrays, debugAssert } from "@fluidframework/core-utils/internal";
+import { EmptyKey, mapCursorField } from "../core/index.js";
+import { eraseSchemaDetails, getInnerNode, SchemaFactory, SchemaFactoryAlpha, TreeArrayNode, } from "../simple-tree/index.js";
 const sf = new SchemaFactoryAlpha("com.fluidframework.text");
 class TextNode extends sf.object("Text", {
     content: SchemaFactory.required([() => StringArray], { key: EmptyKey }),
@@ -11,15 +12,38 @@ class TextNode extends sf.object("Text", {
     insertAt(index, additionalCharacters) {
         this.content.insertAt(index, TreeArrayNode.spread(charactersFromString(additionalCharacters)));
     }
-    removeRange(index, length) {
-        this.content.removeRange(index, length);
+    removeRange(index, end) {
+        this.content.removeRange(index, end);
     }
     characters() {
         return this.content[Symbol.iterator]();
     }
+    characterCount() {
+        return this.content.length;
+    }
+    charactersCopy() {
+        const result = this.content.charactersCopy();
+        debugAssert(() => compareArrays(result, this.charactersCopy_reference()) ||
+            "invalid charactersCopy optimizations");
+        return result;
+    }
     fullString() {
+        const result = this.content.fullString();
+        debugAssert(() => result === this.fullString_reference() || "invalid fullString optimizations");
+        return result;
+    }
+    /**
+     * Unoptimized trivially correct implementation of fullString.
+     */
+    fullString_reference() {
         return this.content.join("");
     }
+    /**
+     * Unoptimized trivially correct implementation of charactersCopy.
+     */
+    charactersCopy_reference() {
+        return [...this.content];
+    }
     static fromString(value) {
         // Constructing an ArrayNode from an iterator is supported, so creating an array from the iterable of characters seems like its not necessary here,
         // but to reduce the risk of incorrect data interpretation, we actually ban this in the special case where the iterable is a string directly, which is the case here.
@@ -41,6 +65,19 @@ export function charactersFromString(value) {
     return value;
 }
 class StringArray extends sf.array("StringArray", SchemaFactory.string) {
+    withBorrowedSequenceCursor(f) {
+        const cursor = getInnerNode(this).borrowCursor();
+        cursor.enterField(EmptyKey);
+        const result = f(cursor);
+        cursor.exitField();
+        return result;
+    }
+    charactersCopy() {
+        return this.withBorrowedSequenceCursor((cursor) => mapCursorField(cursor, () => cursor.value));
+    }
+    fullString() {
+        return this.charactersCopy().join("");
+    }
 }
 /**
  * A collection of text related types, schema and utilities for working with text beyond the basic {@link SchemaStatics.string}.
@@ -102,16 +139,15 @@ class StringArray extends sf.array("StringArray", SchemaFactory.string) {
  *
  * Part of that work will be establishing and documenting those patterns so other components with complex encodings can follow them,
  * in addition to implementing them for text.
- * @internal
+ * @alpha
  */
 export var TextAsTree;
 (function (TextAsTree) {
     /**
-     * Schema for a text node.
+     * Schema for a {@link TextAsTree.(Tree:variable)} node.
      * @remarks
-     * See {@link TextAsTree.Members} for the API.
-     * See {@link TextAsTree.Statics} for static APIs on this Schema, including construction.
-     * @internal
+     * See {@link TextAsTree.Statics} for static APIs on this schema, including construction.
+     * @alpha
      */
     TextAsTree.Tree = eraseSchemaDetails()(TextNode);
 })(TextAsTree || (TextAsTree = {}));

package/lib/text/textDomain.js.map

@@ -1 +1 @@
-{"version":3,"file":"textDomain.js","sourceRoot":"","sources":["../../src/text/textDomain.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EACN,kBAAkB,EAClB,aAAa,EACb,kBAAkB,EAClB,aAAa,GACb,MAAM,yBAAyB,CAAC;AAGjC,MAAM,EAAE,GAAG,IAAI,kBAAkB,CAAC,yBAAyB,CAAC,CAAC;AAE7D,MAAM,QACL,SAAQ,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE;IACzB,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;CACvE,CAAC;IAGK,QAAQ,CAAC,KAAa,EAAE,oBAA4B;QAC1D,IAAI,CAAC,OAAO,CAAC,QAAQ,CACpB,KAAK,EACL,aAAa,CAAC,MAAM,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,CAAC,CAChE,CAAC;IACH,CAAC;IACM,WAAW,CAAC,KAAa,EAAE,MAAc;QAC/C,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACzC,CAAC;IACM,UAAU;QAChB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IACxC,CAAC;IACM,UAAU;QAChB,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC9B,CAAC;IAEM,MAAM,CAAC,UAAU,CAAC,KAAa;QACrC,mJAAmJ;QACnJ,qKAAqK;QACrK,0EAA0E;QAC1E,OAAO,IAAI,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;IACpE,CAAC;CACD;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAa;IACjD,0GAA0G;IAC1G,iKAAiK;IACjK,0CAA0C;IAC1C,OAAO,KAAK,CAAC;AACd,CAAC;AAED,MAAM,WAAY,SAAQ,EAAE,CAAC,KAAK,CAAC,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC;CAAG;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,MAAM,KAAW,UAAU,CA0E1B;AA1ED,WAAiB,UAAU;IAiE1B;;;;;;OAMG;IACU,eAAI,GAAG,kBAAkB,EAAoB,CAAC,QAAQ,CAAC,CAAC;AAEtE,CAAC,EA1EgB,UAAU,KAAV,UAAU,QA0E1B","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { EmptyKey } from \"../core/index.js\";\nimport {\n\teraseSchemaDetails,\n\tSchemaFactory,\n\tSchemaFactoryAlpha,\n\tTreeArrayNode,\n} from \"../simple-tree/index.js\";\nimport type { TreeNode, WithType } from \"../simple-tree/index.js\";\n\nconst sf = new SchemaFactoryAlpha(\"com.fluidframework.text\");\n\nclass TextNode\n\textends sf.object(\"Text\", {\n\t\tcontent: SchemaFactory.required([() => StringArray], { key: EmptyKey }),\n\t})\n\timplements TextAsTree.Members\n{\n\tpublic insertAt(index: number, additionalCharacters: string): void {\n\t\tthis.content.insertAt(\n\t\t\tindex,\n\t\t\tTreeArrayNode.spread(charactersFromString(additionalCharacters)),\n\t\t);\n\t}\n\tpublic removeRange(index: number, length: number): void {\n\t\tthis.content.removeRange(index, length);\n\t}\n\tpublic characters(): Iterable<string> {\n\t\treturn this.content[Symbol.iterator]();\n\t}\n\tpublic fullString(): string {\n\t\treturn this.content.join(\"\");\n\t}\n\n\tpublic static fromString(value: string): TextNode {\n\t\t// Constructing an ArrayNode from an iterator is supported, so creating an array from the iterable of characters seems like its not necessary here,\n\t\t// but to reduce the risk of incorrect data interpretation, we actually ban this in the special case where the iterable is a string directly, which is the case here.\n\t\t// Thus the array construction here is necessary to avoid a runtime error.\n\t\treturn new TextNode({ content: [...charactersFromString(value)] });\n\t}\n}\n\n/**\n * Interpret a string as an iterable of characters.\n * @remarks\n * This mostly exists to clearly document where the code is interpreting a string as characters,\n * and provide a centralized place where validation could be added in the future if desired.\n * Additionally using this function consistently will make any refactors to support alternative character boundaries easier.\n */\nexport function charactersFromString(value: string): Iterable<string> {\n\t// Uses the string as an iterable of characters, so utf-16 surrogate pairs get grouped together correctly.\n\t// Might be nice to call isWellFormed or toWellFormed here (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toWellFormed)\n\t// But those are not widely supported yet.\n\treturn value;\n}\n\nclass StringArray extends sf.array(\"StringArray\", SchemaFactory.string) {}\n\n/**\n * A collection of text related types, schema and utilities for working with text beyond the basic {@link SchemaStatics.string}.\n * @privateRemarks\n * Currently this API only supports a really minimal feature set, and has no support for more advanced features like:\n * - Alternative character boundaries (e.g. grapheme clusters, paragraphs, tokens, etc.).\n * We may want to provide either ways to create strings with application controlled character boundaries since there is not a clear single answer on how to break a string into atomic units.\n * - Character attributes (e.g. bold, italic, etc):\n * Properties that can be set on any character independently with optimizations for runs of characters with the same attributes.\n * - Inline objects (e.g. images, embedded components, etc):\n * These would be logically part of the text, generalizing characters to allow inline objects in character ranges.\n * How character attributes apply to inline objects is an open question\n * (there could be a kind of object which gets them, and one that doesn't for example).\n * - Annotations (e.g. comments, suggestions, etc).\n * Objects which can be associated with a range of characters but are not logically part of the text.\n * These would need to have the logical range they apply to updated by edits.\n * How edits which overlap annotation boundaries are handled may require hints from the application for optimal behavior (mainly inserts at the boundaries).\n * These get a lifetime tied to the text node, not any of the characters the annotation covers,\n * however it might be desirable to have a way for a range edit to (optionally) also remove any annotations which are fully covered by the edit.\n * Annotations over an empty range should also be supported and behave well (for example not end up with characters inside the range after edits unless specifically structured so that makes sense).\n * - Anchors (e.g. positions in the text which survive edits).\n * These would be useful for ephemeral state like cursor positions, but should match the behaviors with respect to edits exhibited by the ends of Annotations.\n *\n * How these features will be represented in the schema and API should be determined before any of this is stabilized so the simple more limited version can neatly fit into the larger design.\n *\n * There are various optimizations that should be implemented to make this performant for large texts and common usage patterns.\n * These include:\n * - Optimized persisted format.\n * - Optimized in memory representation (via chunked forest).\n * - Optimized edit persisted format (e.g. combining adjacent inserts/removes into single operations as well as support for efficient attribute editing of ranges).\n * - Optimized edit application (e.g. applying the above noted optimizable edit cases efficiently).\n * This applies to the revision manager, the forest, and any flex or simple-tree nodes and user events.\n *\n * There are also additional features required for ensuring the invariants of collaborative text editing are maintained through concurrent edits.\n * The main challenges here are related to annotations, but some policies for what to do in the case of corrupt/invalid text should also be included.\n * There are quite a few ways invariants could break, including:\n * - concurrent edits without proper constraints.\n * - collaboration with clients using compatible schema with different constraints.\n * - opening documents which contain invalid content (e.g. from older versions of the software, manual edits to the persisted format, or simply an existing corrupt case which was saved).\n * - a user inserting/constructing/importing invalid content.\n *\n * These cases could break constraints causing issues like invalided characters (empty, a utf-16 surrogate pair alone, etc) or\n * annotations which reference out of bounds character ranges.\n * Addressing these issues mainly falls into these categories:\n * - Handling of invalid content on import/construction of unhydrated nodes and/or insertion into the document (hydration).\n * - Handling of invalid content which is already part of the document (live). This should ideally include both detection and repair.\n * - Constraints on edits to prevent invalid content from being created by merges.\n * - Optimization of the constraints to reduce cases in which edits are rejected due to conflicts.\n *\n * Note that these cases of invariant violations are the same cases any component should handle, so ideally there would be a general framework or pattern for documenting and enforcing such constraints.\n *\n * Another area for future work is improved APIs for import, export and non-schema-aware use. This includes a variety of cases, including but not limited to:\n * - Insertable content format (taken by the constructor and import APIs).\n * - Customizable export formats (like a way to make exportVerbose and exportConcise flatten the text nodes to strings automatically).\n * - Customizable toJson behavior (e.g. flattening to strings, possibly via tools or patterns for custom tree stringifier).\n * - Ensure JS object APIs (like iteration, own vs inherited properties, etc) provide a good and consistent experience with respect to other nodes.\n * - Support in generateSchemaFromSimpleSchema for recognizing text nodes and generating the appropriate schema.\n * - Ensure above features work well enough to support important scenarios like AI assisted editing and document indexing for search.\n *\n * Part of that work will be establishing and documenting those patterns so other components with complex encodings can follow them,\n * in addition to implementing them for text.\n * @internal\n */\nexport namespace TextAsTree {\n\t/**\n\t * Statics for text nodes.\n\t * @internal\n\t */\n\texport interface Statics {\n\t\t/**\n\t\t * Construct a {@link TextAsTree.(Tree:type)} from a string, where each character (as defined by iterating over the string) becomes a single character in the text node.\n\t\t * This combines pairs of utf-16 surrogate code units into single characters as appropriate.\n\t\t */\n\t\tfromString(value: string): Tree;\n\t}\n\n\t/**\n\t * Interface for a text node.\n\t * @remarks\n\t * The string is broken up into substrings which are referred to as 'characters'.\n\t * Unlike with JavaScript strings, all indexes are by character, not UTF-16 code unit.\n\t * This avoids the problem JavaScript where it can split UTF-16 surrogate pairs producing invalid strings,\n\t * and avoids the issue where indexing a string and iterating it segment the string differently.\n\t * This does NOT mean the characters correspond to user perceived characters (like grapheme clusters try to do):\n\t * applications will likely want to include higher level segmentation logic\n\t * which might differ between operations like delete\n\t * (which often operates on something in between unicode code points and grapheme clusters)\n\t * and navigation/selection (which typically uses grapheme clusters).\n\t *\n\t * @see {@link TextAsTree.Statics.fromString} for construction.\n\t * @see {@link TextAsTree.(Tree:type)} for schema.\n\t * @internal\n\t */\n\texport interface Members {\n\t\t/**\n\t\t * Gets an iterable over the characters currently in the text.\n\t\t * @remarks\n\t\t * This iterator matches the behavior of {@link (TreeArrayNode:interface)} with respect to edits during iteration.\n\t\t */\n\t\tcharacters(): Iterable<string>;\n\n\t\t/**\n\t\t * Copy the content of this node into a string.\n\t\t */\n\t\tfullString(): string;\n\n\t\t/**\n\t\t * Insert a range of characters into the string based on character index.\n\t\t * @remarks\n\t\t * See {@link (TreeArrayNode:interface).insertAt} for more details on the behavior.\n\t\t * See {@link TextAsTree.Statics.fromString} for how the `additionalCharacters` string is broken into characters.\n\t\t * @privateRemarks\n\t\t * If we provide ways to customize character boundaries, that could be handled here by taking in an Iterable<string> instead of a string.\n\t\t * Doing this currently would enable insertion of text with different character boundaries than the existing text,\n\t\t * which would violate the currently documented character boundary invariants.\n\t\t *\n\t\t * Another option would be to take an approach like Table,\n\t\t * where the user of the API uses a factory function to generate the schema, and can inject custom logic, like a string character iterator.\n\t\t */\n\t\tinsertAt(index: number, additionalCharacters: string): void;\n\n\t\t/**\n\t\t * Remove a range from a string based on character index.\n\t\t * See {@link (TreeArrayNode:interface).removeRange} for more details on the behavior.\n\t\t */\n\t\tremoveRange(index: number, length: number): void;\n\t}\n\n\t/**\n\t * Schema for a text node.\n\t * @remarks\n\t * See {@link TextAsTree.Members} for the API.\n\t * See {@link TextAsTree.Statics} for static APIs on this Schema, including construction.\n\t * @internal\n\t */\n\texport const Tree = eraseSchemaDetails<Members, Statics>()(TextNode);\n\texport type Tree = Members & TreeNode & WithType<\"com.fluidframework.text.Text\">;\n}\n"]}
+{"version":3,"file":"textDomain.js","sourceRoot":"","sources":["../../src/text/textDomain.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAC;AAEjF,OAAO,EAAE,QAAQ,EAAE,cAAc,EAA+B,MAAM,kBAAkB,CAAC;AACzF,OAAO,EACN,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,kBAAkB,EAClB,aAAa,GACb,MAAM,yBAAyB,CAAC;AAQjC,MAAM,EAAE,GAAG,IAAI,kBAAkB,CAAC,yBAAyB,CAAC,CAAC;AAE7D,MAAM,QACL,SAAQ,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE;IACzB,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;CACvE,CAAC;IAGK,QAAQ,CAAC,KAAa,EAAE,oBAA4B;QAC1D,IAAI,CAAC,OAAO,CAAC,QAAQ,CACpB,KAAK,EACL,aAAa,CAAC,MAAM,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,CAAC,CAChE,CAAC;IACH,CAAC;IACM,WAAW,CAAC,KAAyB,EAAE,GAAuB;QACpE,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IACtC,CAAC;IACM,UAAU;QAChB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IACxC,CAAC;IAEM,cAAc;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;IAC5B,CAAC;IAEM,cAAc;QACpB,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;QAC7C,WAAW,CACV,GAAG,EAAE,CACJ,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,wBAAwB,EAAE,CAAC;YACtD,sCAAsC,CACvC,CAAC;QACF,OAAO,MAAM,CAAC;IACf,CAAC;IAEM,UAAU;QAChB,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;QACzC,WAAW,CACV,GAAG,EAAE,CAAC,MAAM,KAAK,IAAI,CAAC,oBAAoB,EAAE,IAAI,kCAAkC,CAClF,CAAC;QACF,OAAO,MAAM,CAAC;IACf,CAAC;IAED;;OAEG;IACI,oBAAoB;QAC1B,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC9B,CAAC;IAED;;OAEG;IACI,wBAAwB;QAC9B,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;IAC1B,CAAC;IAEM,MAAM,CAAC,UAAU,CAAC,KAAa;QACrC,mJAAmJ;QACnJ,qKAAqK;QACrK,0EAA0E;QAC1E,OAAO,IAAI,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;IACpE,CAAC;CACD;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAa;IACjD,0GAA0G;IAC1G,iKAAiK;IACjK,0CAA0C;IAC1C,OAAO,KAAK,CAAC;AACd,CAAC;AAED,MAAM,WAAY,SAAQ,EAAE,CAAC,KAAK,CAAC,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC;IAC/D,0BAA0B,CAAI,CAAwC;QAC5E,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,CAAC;QACjD,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QAC5B,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;QACzB,MAAM,CAAC,SAAS,EAAE,CAAC;QACnB,OAAO,MAAM,CAAC;IACf,CAAC;IAEM,cAAc;QACpB,OAAO,IAAI,CAAC,0BAA0B,CAAC,CAAC,MAAM,EAAE,EAAE,CACjD,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,KAAe,CAAC,CACpD,CAAC;IACH,CAAC;IAEM,UAAU;QAChB,OAAO,IAAI,CAAC,cAAc,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACvC,CAAC;CACD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,MAAM,KAAW,UAAU,CA8F1B;AA9FD,WAAiB,UAAU;IA+E1B;;;;;OAKG;IACU,eAAI,GAAG,kBAAkB,EAAoB,CAAC,QAAQ,CAAC,CAAC;AAStE,CAAC,EA9FgB,UAAU,KAAV,UAAU,QA8F1B","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { compareArrays, debugAssert } from \"@fluidframework/core-utils/internal\";\n\nimport { EmptyKey, mapCursorField, type ITreeCursorSynchronous } from \"../core/index.js\";\nimport {\n\teraseSchemaDetails,\n\tgetInnerNode,\n\tSchemaFactory,\n\tSchemaFactoryAlpha,\n\tTreeArrayNode,\n} from \"../simple-tree/index.js\";\n// eslint-disable-next-line import-x/no-duplicates\nimport type { TreeNode, WithType } from \"../simple-tree/index.js\";\n// Add some unused imports which show up in the generated d.ts file.\n// This prevents them from getting inline imports generated, cleaning up the d.ts file and API reports.\n// eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports, import-x/no-duplicates\nimport type { NodeKind, TreeNodeSchema } from \"../simple-tree/index.js\";\n\nconst sf = new SchemaFactoryAlpha(\"com.fluidframework.text\");\n\nclass TextNode\n\textends sf.object(\"Text\", {\n\t\tcontent: SchemaFactory.required([() => StringArray], { key: EmptyKey }),\n\t})\n\timplements TextAsTree.Members\n{\n\tpublic insertAt(index: number, additionalCharacters: string): void {\n\t\tthis.content.insertAt(\n\t\t\tindex,\n\t\t\tTreeArrayNode.spread(charactersFromString(additionalCharacters)),\n\t\t);\n\t}\n\tpublic removeRange(index: number | undefined, end: number | undefined): void {\n\t\tthis.content.removeRange(index, end);\n\t}\n\tpublic characters(): Iterable<string> {\n\t\treturn this.content[Symbol.iterator]();\n\t}\n\n\tpublic characterCount(): number {\n\t\treturn this.content.length;\n\t}\n\n\tpublic charactersCopy(): string[] {\n\t\tconst result = this.content.charactersCopy();\n\t\tdebugAssert(\n\t\t\t() =>\n\t\t\t\tcompareArrays(result, this.charactersCopy_reference()) ||\n\t\t\t\t\"invalid charactersCopy optimizations\",\n\t\t);\n\t\treturn result;\n\t}\n\n\tpublic fullString(): string {\n\t\tconst result = this.content.fullString();\n\t\tdebugAssert(\n\t\t\t() => result === this.fullString_reference() || \"invalid fullString optimizations\",\n\t\t);\n\t\treturn result;\n\t}\n\n\t/**\n\t * Unoptimized trivially correct implementation of fullString.\n\t */\n\tpublic fullString_reference(): string {\n\t\treturn this.content.join(\"\");\n\t}\n\n\t/**\n\t * Unoptimized trivially correct implementation of charactersCopy.\n\t */\n\tpublic charactersCopy_reference(): string[] {\n\t\treturn [...this.content];\n\t}\n\n\tpublic static fromString(value: string): TextNode {\n\t\t// Constructing an ArrayNode from an iterator is supported, so creating an array from the iterable of characters seems like its not necessary here,\n\t\t// but to reduce the risk of incorrect data interpretation, we actually ban this in the special case where the iterable is a string directly, which is the case here.\n\t\t// Thus the array construction here is necessary to avoid a runtime error.\n\t\treturn new TextNode({ content: [...charactersFromString(value)] });\n\t}\n}\n\n/**\n * Interpret a string as an iterable of characters.\n * @remarks\n * This mostly exists to clearly document where the code is interpreting a string as characters,\n * and provide a centralized place where validation could be added in the future if desired.\n * Additionally using this function consistently will make any refactors to support alternative character boundaries easier.\n */\nexport function charactersFromString(value: string): Iterable<string> {\n\t// Uses the string as an iterable of characters, so utf-16 surrogate pairs get grouped together correctly.\n\t// Might be nice to call isWellFormed or toWellFormed here (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toWellFormed)\n\t// But those are not widely supported yet.\n\treturn value;\n}\n\nclass StringArray extends sf.array(\"StringArray\", SchemaFactory.string) {\n\tpublic withBorrowedSequenceCursor<T>(f: (cursor: ITreeCursorSynchronous) => T): T {\n\t\tconst cursor = getInnerNode(this).borrowCursor();\n\t\tcursor.enterField(EmptyKey);\n\t\tconst result = f(cursor);\n\t\tcursor.exitField();\n\t\treturn result;\n\t}\n\n\tpublic charactersCopy(): string[] {\n\t\treturn this.withBorrowedSequenceCursor((cursor) =>\n\t\t\tmapCursorField(cursor, () => cursor.value as string),\n\t\t);\n\t}\n\n\tpublic fullString(): string {\n\t\treturn this.charactersCopy().join(\"\");\n\t}\n}\n\n/**\n * A collection of text related types, schema and utilities for working with text beyond the basic {@link SchemaStatics.string}.\n * @privateRemarks\n * Currently this API only supports a really minimal feature set, and has no support for more advanced features like:\n * - Alternative character boundaries (e.g. grapheme clusters, paragraphs, tokens, etc.).\n * We may want to provide either ways to create strings with application controlled character boundaries since there is not a clear single answer on how to break a string into atomic units.\n * - Character attributes (e.g. bold, italic, etc):\n * Properties that can be set on any character independently with optimizations for runs of characters with the same attributes.\n * - Inline objects (e.g. images, embedded components, etc):\n * These would be logically part of the text, generalizing characters to allow inline objects in character ranges.\n * How character attributes apply to inline objects is an open question\n * (there could be a kind of object which gets them, and one that doesn't for example).\n * - Annotations (e.g. comments, suggestions, etc).\n * Objects which can be associated with a range of characters but are not logically part of the text.\n * These would need to have the logical range they apply to updated by edits.\n * How edits which overlap annotation boundaries are handled may require hints from the application for optimal behavior (mainly inserts at the boundaries).\n * These get a lifetime tied to the text node, not any of the characters the annotation covers,\n * however it might be desirable to have a way for a range edit to (optionally) also remove any annotations which are fully covered by the edit.\n * Annotations over an empty range should also be supported and behave well (for example not end up with characters inside the range after edits unless specifically structured so that makes sense).\n * - Anchors (e.g. positions in the text which survive edits).\n * These would be useful for ephemeral state like cursor positions, but should match the behaviors with respect to edits exhibited by the ends of Annotations.\n *\n * How these features will be represented in the schema and API should be determined before any of this is stabilized so the simple more limited version can neatly fit into the larger design.\n *\n * There are various optimizations that should be implemented to make this performant for large texts and common usage patterns.\n * These include:\n * - Optimized persisted format.\n * - Optimized in memory representation (via chunked forest).\n * - Optimized edit persisted format (e.g. combining adjacent inserts/removes into single operations as well as support for efficient attribute editing of ranges).\n * - Optimized edit application (e.g. applying the above noted optimizable edit cases efficiently).\n * This applies to the revision manager, the forest, and any flex or simple-tree nodes and user events.\n *\n * There are also additional features required for ensuring the invariants of collaborative text editing are maintained through concurrent edits.\n * The main challenges here are related to annotations, but some policies for what to do in the case of corrupt/invalid text should also be included.\n * There are quite a few ways invariants could break, including:\n * - concurrent edits without proper constraints.\n * - collaboration with clients using compatible schema with different constraints.\n * - opening documents which contain invalid content (e.g. from older versions of the software, manual edits to the persisted format, or simply an existing corrupt case which was saved).\n * - a user inserting/constructing/importing invalid content.\n *\n * These cases could break constraints causing issues like invalided characters (empty, a utf-16 surrogate pair alone, etc) or\n * annotations which reference out of bounds character ranges.\n * Addressing these issues mainly falls into these categories:\n * - Handling of invalid content on import/construction of unhydrated nodes and/or insertion into the document (hydration).\n * - Handling of invalid content which is already part of the document (live). This should ideally include both detection and repair.\n * - Constraints on edits to prevent invalid content from being created by merges.\n * - Optimization of the constraints to reduce cases in which edits are rejected due to conflicts.\n *\n * Note that these cases of invariant violations are the same cases any component should handle, so ideally there would be a general framework or pattern for documenting and enforcing such constraints.\n *\n * Another area for future work is improved APIs for import, export and non-schema-aware use. This includes a variety of cases, including but not limited to:\n * - Insertable content format (taken by the constructor and import APIs).\n * - Customizable export formats (like a way to make exportVerbose and exportConcise flatten the text nodes to strings automatically).\n * - Customizable toJson behavior (e.g. flattening to strings, possibly via tools or patterns for custom tree stringifier).\n * - Ensure JS object APIs (like iteration, own vs inherited properties, etc) provide a good and consistent experience with respect to other nodes.\n * - Support in generateSchemaFromSimpleSchema for recognizing text nodes and generating the appropriate schema.\n * - Ensure above features work well enough to support important scenarios like AI assisted editing and document indexing for search.\n *\n * Part of that work will be establishing and documenting those patterns so other components with complex encodings can follow them,\n * in addition to implementing them for text.\n * @alpha\n */\nexport namespace TextAsTree {\n\t/**\n\t * Statics for text nodes.\n\t * @alpha\n\t */\n\texport interface Statics {\n\t\t/**\n\t\t * Construct a {@link TextAsTree.(Tree:type)} from a string, where each character (as defined by iterating over the string) becomes a single character in the text node.\n\t\t * This combines pairs of utf-16 surrogate code units into single characters as appropriate.\n\t\t */\n\t\tfromString(value: string): Tree;\n\t}\n\n\t/**\n\t * Interface for a text node.\n\t * @remarks\n\t * The string is broken up into substrings which are referred to as 'characters'.\n\t * Unlike with JavaScript strings, all indexes are by character, not UTF-16 code unit.\n\t * This avoids the problem JavaScript where it can split UTF-16 surrogate pairs producing invalid strings,\n\t * and avoids the issue where indexing a string and iterating it segment the string differently.\n\t * This does NOT mean the characters correspond to user perceived characters (like grapheme clusters try to do):\n\t * applications will likely want to include higher level segmentation logic\n\t * which might differ between operations like delete\n\t * (which often operates on something in between unicode code points and grapheme clusters)\n\t * and navigation/selection (which typically uses grapheme clusters).\n\t *\n\t * @see {@link TextAsTree.Statics.fromString} for construction.\n\t * @see {@link TextAsTree.(Tree:type)} for schema.\n\t * @alpha\n\t */\n\texport interface Members {\n\t\t/**\n\t\t * Gets an iterable over the characters currently in the text.\n\t\t * @remarks\n\t\t * This iterator matches the behavior of {@link (TreeArrayNode:interface)} with respect to edits during iteration.\n\t\t */\n\t\tcharacters(): Iterable<string>;\n\n\t\t/**\n\t\t * Optimized way to get a copy of the {@link TextAsTree.Members.characters} in an array.\n\t\t */\n\t\tcharactersCopy(): string[];\n\n\t\t/**\n\t\t * Gets the number of characters currently in the text.\n\t\t * @remarks\n\t\t * The length of {@link TextAsTree.Members.characters}.\n\t\t * This is not the length of the string returned by {@link TextAsTree.Members.fullString},\n\t\t * as that string may contain characters which are made up of multiple UTF-16 code units.\n\t\t */\n\t\tcharacterCount(): number;\n\n\t\t/**\n\t\t * Copy the content of this node into a string.\n\t\t */\n\t\tfullString(): string;\n\n\t\t/**\n\t\t * Insert a range of characters into the string based on character index.\n\t\t * @remarks\n\t\t * See {@link (TreeArrayNode:interface).insertAt} for more details on the behavior.\n\t\t * See {@link TextAsTree.Statics.fromString} for how the `additionalCharacters` string is broken into characters.\n\t\t * @privateRemarks\n\t\t * If we provide ways to customize character boundaries, that could be handled here by taking in an Iterable<string> instead of a string.\n\t\t * Doing this currently would enable insertion of text with different character boundaries than the existing text,\n\t\t * which would violate the currently documented character boundary invariants.\n\t\t *\n\t\t * Another option would be to take an approach like Table,\n\t\t * where the user of the API uses a factory function to generate the schema, and can inject custom logic, like a string character iterator.\n\t\t */\n\t\tinsertAt(index: number, additionalCharacters: string): void;\n\n\t\t/**\n\t\t * Remove a range from a string based on character index.\n\t\t * See {@link (TreeArrayNode:interface).removeRange} for more details on the behavior.\n\t\t */\n\t\tremoveRange(startIndex: number | undefined, endIndex: number | undefined): void;\n\t}\n\n\t/**\n\t * Schema for a {@link TextAsTree.(Tree:variable)} node.\n\t * @remarks\n\t * See {@link TextAsTree.Statics} for static APIs on this schema, including construction.\n\t * @alpha\n\t */\n\texport const Tree = eraseSchemaDetails<Members, Statics>()(TextNode);\n\n\t/**\n\t * Node for the {@link TextAsTree.(Tree:type)} schema exposing the {@link TextAsTree.Members} API.\n\t * @remarks\n\t * Create using {@link TextAsTree.Statics.fromString}.\n\t * @alpha\n\t */\n\texport type Tree = Members & TreeNode & WithType<\"com.fluidframework.text.Text\">;\n}\n"]}

package/lib/text/textDomainFormatted.d.ts

@@ -14,15 +14,13 @@ import { type TextAsTree } from "./textDomain.js";
  * @internal
  */
 export declare namespace FormattedTextAsTree {
-    const CharacterFormat_base: import("../simple-tree/index.js").ObjectNodeSchema<"com.fluidframework.text.formatted.CharacterFormat", {
+    const CharacterFormat_base: import("../simple-tree/index.js").ObjectNodeSchemaWorkaround<"com.fluidframework.text.formatted.CharacterFormat", {
         readonly bold: import("../simple-tree/leafNodeSchema.js").LeafSchema<"boolean", boolean>;
         readonly italic: import("../simple-tree/leafNodeSchema.js").LeafSchema<"boolean", boolean>;
         readonly underline: import("../simple-tree/leafNodeSchema.js").LeafSchema<"boolean", boolean>;
         readonly size: import("../simple-tree/leafNodeSchema.js").LeafSchema<"number", number>;
         readonly font: import("../simple-tree/leafNodeSchema.js").LeafSchema<"string", string>;
-    }, true, unknown> & {
-        readonly createFromInsertable: unknown;
-    };
+    }, true, unknown>;
     /**
      * Formatting options for characters.
      * @internal
@@ -83,12 +81,12 @@ export declare namespace FormattedTextAsTree {
         h4: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.lineTag.h4" | "com.h4", import("../simple-tree/index.js").NodeKind.Object, TreeNode & {
             readonly value: "h4";
         }, Record<string, never>, true, Record<string, never>, undefined>;
-        h5: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.lineTag.h5" | "com.h5", import("../simple-tree/index.js").NodeKind.Object, TreeNode & {
-            readonly value: "h5";
-        }, Record<string, never>, true, Record<string, never>, undefined>;
         li: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.lineTag.li" | "com.li", import("../simple-tree/index.js").NodeKind.Object, TreeNode & {
             readonly value: "li";
         }, Record<string, never>, true, Record<string, never>, undefined>;
+        h5: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.lineTag.h5" | "com.h5", import("../simple-tree/index.js").NodeKind.Object, TreeNode & {
+            readonly value: "h5";
+        }, Record<string, never>, true, Record<string, never>, undefined>;
     } & {
         readonly schema: [import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.lineTag.li" | "com.li", import("../simple-tree/index.js").NodeKind.Object, TreeNode & {
             readonly value: "li";
@@ -531,11 +529,15 @@ export declare namespace FormattedTextAsTree {
          */
         defaultFormat: CharacterFormat;
         /**
-         * Gets an iterable over the characters currently in the text.
+         * Gets an array type view of the characters currently in the text.
          * @remarks
          * This iterator matches the behavior of {@link (TreeArrayNode:interface)} with respect to edits during iteration.
+         * @privateRemarks
+         * Currently this is implemented by a node and changes with the text over time.
+         * We might not want to leak a node like this in the API.
+         * Providing a way to index and iterate separately might be better.
          */
-        charactersWithFormatting(): Iterable<StringAtom>;
+        charactersWithFormatting(): readonly StringAtom[];
         /**
          * Insert a range of characters into the string based on character index.
          * @remarks
@@ -552,11 +554,13 @@ export declare namespace FormattedTextAsTree {
         insertWithFormattingAt(index: number, additionalCharacters: Iterable<InsertableTypedNode<typeof StringAtom>>): void;
         /**
          * Apply formatting to a range of characters based on character index.
-         * @param startIndex - The starting index of the range to format.
-         * @param length - The number of characters to format.
+         * @param startIndex - The starting index (inclusive) of the range to format.
+         * @param endIndex - The ending index (exclusive) of the range to format.
          * @param format - The formatting to apply to the specified range.
+         * @remarks
+         * The start and end behave the same as in {@link (TreeArrayNode:interface).removeRange}.
          */
-        formatRange(startIndex: number, length: number, format: Partial<CharacterFormat>): void;
+        formatRange(startIndex: number | undefined, endIndex: number | undefined, format: Partial<CharacterFormat>): void;
     }
     /**
      * Schema for a text node.

package/lib/text/textDomainFormatted.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"textDomainFormatted.d.ts","sourceRoot":"","sources":["../../src/text/textDomainFormatted.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAeH,OAAO,KAAK,EACX,mBAAmB,EACnB,QAAQ,EACR,gCAAgC,EAChC,QAAQ,EACR,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAwB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AA+HxE;;;;;;;;GAQG;AACH,yBAAiB,mBAAmB,CAAC;;;;;;;;;;IACpC;;;OAGG;IACH,MAAM,OAAO,eAAgB,SAAQ,oBAMnC;KAAG;;QAOJ;;;;;;;;;;WAUG;;;;;QAVH;;;;;;;;;;WAUG;;;IAfJ;;;OAGG;IACH,MAAM,OAAO,cAAe,SAAQ,mBAalC;KAAG;IAEL;;;OAGG;IACH,MAAM,CAAC,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOlB,CAAC;IACH;;;OAGG;IACH,MAAM,MAAM,OAAO,GAAG,gCAAgC,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE9E;;;;;;;OAOG;IACH,MAAM,OAAO,cAAe,SAAQ,mBAElC;QACD,SAAgB,OAAO,QAAQ;KAC/B;IAED;;;OAGG;IACH,MAAM,CAAC,MAAM,iBAAiB,yDAA4C,CAAC;IAC3E;;;OAGG;IACH,MAAM,MAAM,iBAAiB,GAAG,gCAAgC,CAAC,OAAO,iBAAiB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE3F;;;OAGG;IACH,MAAM,OAAO,UAAW,SAAQ,eAG9B;KAAG;IAEL;;;OAGG;IACH,MAAM,WAAW,OAAO;QACvB;;;WAGG;QACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;KAChC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,WAAW,OAAQ,SAAQ,UAAU,CAAC,OAAO;QAClD;;;;;;WAMG;QACH,aAAa,EAAE,eAAe,CAAC;QAE/B;;;;WAIG;QACH,wBAAwB,IAAI,QAAQ,CAAC,UAAU,CAAC,CAAC;QAEjD;;;;;;;;;;;;WAYG;QACH,sBAAsB,CACrB,KAAK,EAAE,MAAM,EACb,oBAAoB,EAAE,QAAQ,CAAC,mBAAmB,CAAC,OAAO,UAAU,CAAC,CAAC,GACpE,IAAI,CAAC;QAER;;;;;WAKG;QACH,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC;KACxF;IAED;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,IAAI,8RAAmD,CAAC;IACrE,MAAM,MAAM,IAAI,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC,wCAAwC,CAAC,CAAC;;CAC3F"}
+{"version":3,"file":"textDomainFormatted.d.ts","sourceRoot":"","sources":["../../src/text/textDomainFormatted.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAiBH,OAAO,KAAK,EACX,mBAAmB,EACnB,QAAQ,EACR,gCAAgC,EAChC,QAAQ,EACR,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAwB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAmOxE;;;;;;;;GAQG;AACH,yBAAiB,mBAAmB,CAAC;;;;;;;;IACpC;;;OAGG;IACH,MAAM,OAAO,eAAgB,SAAQ,oBAMnC;KAAG;;QAOJ;;;;;;;;;;WAUG;;;;;QAVH;;;;;;;;;;WAUG;;;IAfJ;;;OAGG;IACH,MAAM,OAAO,cAAe,SAAQ,mBAalC;KAAG;IAEL;;;OAGG;IACH,MAAM,CAAC,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOlB,CAAC;IACH;;;OAGG;IACH,MAAM,MAAM,OAAO,GAAG,gCAAgC,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE9E;;;;;;;OAOG;IACH,MAAM,OAAO,cAAe,SAAQ,mBAElC;QACD,SAAgB,OAAO,QAAQ;KAC/B;IAED;;;OAGG;IACH,MAAM,CAAC,MAAM,iBAAiB,yDAA4C,CAAC;IAC3E;;;OAGG;IACH,MAAM,MAAM,iBAAiB,GAAG,gCAAgC,CAAC,OAAO,iBAAiB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE3F;;;OAGG;IACH,MAAM,OAAO,UAAW,SAAQ,eAG9B;KAAG;IAEL;;;OAGG;IACH,MAAM,WAAW,OAAO;QACvB;;;WAGG;QACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;KAChC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,WAAW,OAAQ,SAAQ,UAAU,CAAC,OAAO;QAClD;;;;;;WAMG;QACH,aAAa,EAAE,eAAe,CAAC;QAE/B;;;;;;;;WAQG;QACH,wBAAwB,IAAI,SAAS,UAAU,EAAE,CAAC;QAElD;;;;;;;;;;;;WAYG;QACH,sBAAsB,CACrB,KAAK,EAAE,MAAM,EACb,oBAAoB,EAAE,QAAQ,CAAC,mBAAmB,CAAC,OAAO,UAAU,CAAC,CAAC,GACpE,IAAI,CAAC;QAER;;;;;;;WAOG;QACH,WAAW,CACV,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,GAC9B,IAAI,CAAC;KACR;IAED;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,IAAI,8RAAmD,CAAC;IACrE,MAAM,MAAM,IAAI,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC,wCAAwC,CAAC,CAAC;;CAC3F"}

package/lib/text/textDomainFormatted.js

@@ -2,12 +2,13 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, compareArrays, debugAssert, fail } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
-import { EmptyKey } from "../core/index.js";
+import { EmptyKey, mapCursorField } from "../core/index.js";
+import { currentObserver } from "../feature-libraries/index.js";
 import { TreeAlpha } from "../shared-tree/index.js";
-import { enumFromStrings, eraseSchemaDetails, SchemaFactory, SchemaFactoryAlpha, TreeArrayNode, TreeBeta, } from "../simple-tree/index.js";
-import { mapIterable } from "../util/index.js";
+import { enumFromStrings, eraseSchemaDetails, getInnerNode, SchemaFactory, SchemaFactoryAlpha, TreeArrayNode, TreeBeta, } from "../simple-tree/index.js";
+import { mapIterable, validateIndex, validateIndexRange } from "../util/index.js";
 import { charactersFromString } from "./textDomain.js";
 const sf = new SchemaFactoryAlpha("com.fluidframework.text.formatted");
 class TextNode extends sf.object("Text", {
@@ -20,15 +21,38 @@ class TextNode extends sf.object("Text", {
     insertAt(index, additionalCharacters) {
         this.content.insertAt(index, TreeArrayNode.spread(textAtomsFromString(additionalCharacters, this.defaultFormat)));
     }
-    removeRange(index, length) {
-        this.content.removeRange(index, length);
+    removeRange(index, end) {
+        this.content.removeRange(index, end);
     }
     characters() {
         return mapIterable(this.content, (atom) => atom.content.content);
     }
+    charactersCopy() {
+        const result = this.content.charactersCopy();
+        debugAssert(() => compareArrays(result, this.charactersCopy_reference()) ||
+            "invalid charactersCopy optimizations");
+        return result;
+    }
+    characterCount() {
+        return this.content.length;
+    }
     fullString() {
+        const result = this.content.fullString();
+        debugAssert(() => result === this.fullString_reference() || "invalid fullString optimizations");
+        return result;
+    }
+    /**
+     * A non-optimized reference implementation of fullString.
+     */
+    fullString_reference() {
         return [...this.characters()].join("");
     }
+    /**
+     * Unoptimized trivially correct implementation of charactersCopy.
+     */
+    charactersCopy_reference() {
+        return [...this.characters()];
+    }
     static fromString(value, format) {
         // Constructing an ArrayNode from an iterator is supported, so creating an array from the iterable of characters seems like it's not necessary here,
         // but to reduce the risk of incorrect data interpretation, we actually ban this in the special case where the iterable is a string directly, which is the case here.
@@ -45,10 +69,14 @@ class TextNode extends sf.object("Text", {
     insertWithFormattingAt(index, additionalCharacters) {
         this.content.insertAt(index, TreeArrayNode.spread(additionalCharacters));
     }
-    formatRange(startIndex, length, format) {
+    formatRange(start, end, format) {
+        const formatStart = start ?? 0;
+        validateIndex(formatStart, this.content, "FormattedTextAsTree.formatRange", true);
+        const formatEnd = Math.min(this.content.length, end ?? this.content.length);
+        validateIndexRange(formatStart, formatEnd, this.content, "FormattedTextAsTree.formatRange");
         const branch = TreeAlpha.branch(this);
         const applyFormatting = () => {
-            for (let i = startIndex; i < startIndex + length; i++) {
+            for (let i = formatStart; i < formatEnd; i++) {
                 const atom = this.content[i];
                 if (atom === undefined) {
                     throw new UsageError("Index out of bounds while formatting text range.");
@@ -95,6 +123,50 @@ function textAtomsFromString(value, format) {
     return result;
 }
 class StringArray extends sf.array("StringArray", [() => FormattedTextAsTree.StringAtom]) {
+    withBorrowedSequenceCursor(f) {
+        const innerNode = getInnerNode(this);
+        // Since the cursor will be used to read content from the tree and won't track observations,
+        // treat it as if it observed the whole subtree.
+        currentObserver?.observeNodeDeep(innerNode);
+        const cursor = innerNode.borrowCursor();
+        cursor.enterField(EmptyKey);
+        const result = f(cursor);
+        cursor.exitField();
+        return result;
+    }
+    charactersCopy() {
+        return this.withBorrowedSequenceCursor((cursor) => mapCursorField(cursor, () => {
+            debugAssert(() => cursor.type === FormattedTextAsTree.StringAtom.identifier ||
+                "invalid fullString type optimizations");
+            cursor.enterField(EmptyKey);
+            cursor.enterNode(0);
+            let content;
+            switch (cursor.type) {
+                case FormattedTextAsTree.StringTextAtom.identifier: {
+                    cursor.enterField(EmptyKey);
+                    cursor.enterNode(0);
+                    content = cursor.value;
+                    debugAssert(() => typeof content === "string" || "invalid fullString type optimizations");
+                    cursor.exitNode();
+                    cursor.exitField();
+                    break;
+                }
+                case FormattedTextAsTree.StringLineAtom.identifier: {
+                    content = "\n";
+                    break;
+                }
+                default: {
+                    fail(0xcde /* Unsupported node type in text array */, () => `${cursor.type}`);
+                }
+            }
+            cursor.exitNode();
+            cursor.exitField();
+            return content;
+        }));
+    }
+    fullString() {
+        return this.charactersCopy().join("");
+    }
 }
 /**
  * A collection of text related types, schema and utilities for working with text beyond the basic {@link SchemaStatics.string}.