@fluidframework/tree 2.118.0 → 3.0.0

package/lib/text/codePointUtils.d.ts

@@ -14,15 +14,23 @@
  * codePointCount("abc");  // 3
  * codePointCount("a😀b"); // 3 — emoji is one code point, but "a😀b".length === 4 (UTF-16 surrogate pair)
  * ```
+ * @privateRemarks
+ * Users of this are assuming the segmentation of their string exactly matches what our text utils do.
+ * If they are using this to evaluate what they will do, it might be better to just use the text APIs directly, and measure the resulting length.
+ * If measuring what they did, then measuring the length of the resulting character array would likely be better.
+ * In short: using this typically means making an assumption about how data in one of our string arrays is or will be segmented,
+ * which can't always be robust since it's possible to violate our default segmentation policy via round tripping the data and injecting irregular segments.
+ * Additionally, using this likely means you will have problems if/when handling embedded objects.
+ * Therefore we might want to reevaluate the code using this, instead of promoting it to a more stable API surface and encouraging use of it.
  *
- * @internal
+ * @alpha
  */
 export declare function codePointCount(value: string): number;
 /**
  * Returns the number of UTF-16 code units occupied by the first `count` Unicode code points in `value`,
  * starting at UTF-16 index `start`.
  * @remarks
- * Use this to translate {@link PlainText}-space counts (code points) into JavaScript string indices (UTF-16).
+ * Use this to translate {@link PlainText} substring lengths (code points) into JavaScript string lengths (UTF-16).
  * One code point outside the Basic Multilingual Plane (e.g. most emoji) occupies two UTF-16 code units.
  *
  * Validates that the requested `count` code points are fully consumable from `start`; silent truncation
@@ -40,9 +48,14 @@ export declare function codePointCount(value: string): number;
  * @param start - The UTF-16 index in `value` to start measuring from. Must be in `[0, value.length]`.
  * @param count - The number of Unicode code points to measure. Must be non-negative, and there must
  * be at least `count` code points available in `value` starting at `start`.
+ * @returns The number of UTF-16 code units occupied by the requested code points.
  * @throws A {@link @fluidframework/telemetry-utils#UsageError} if `start` is out of range,
  * `count` is negative, or fewer than `count` code points are available from `start`.
- * @internal
+ *
+ * @privateRemarks
+ * See remarks on {@link codePointCount} regarding the stability of this API and its assumptions about string segmentation.
+ *
+ * @alpha
  */
 export declare function utf16LengthForCodePoints(value: string, start: number, count: number): number;
 //# sourceMappingURL=codePointUtils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"codePointUtils.d.ts","sourceRoot":"","sources":["../../src/text/codePointUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAuB5F"}
+{"version":3,"file":"codePointUtils.d.ts","sourceRoot":"","sources":["../../src/text/codePointUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAmB5F"}

package/lib/text/codePointUtils.js

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import { validateIndex } from "../util/index.js";
 /**
  * Returns the number of Unicode code points in `value`.
  * @remarks
@@ -15,8 +16,16 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
  * codePointCount("abc");  // 3
  * codePointCount("a😀b"); // 3 — emoji is one code point, but "a😀b".length === 4 (UTF-16 surrogate pair)
  * ```
+ * @privateRemarks
+ * Users of this are assuming the segmentation of their string exactly matches what our text utils do.
+ * If they are using this to evaluate what they will do, it might be better to just use the text APIs directly, and measure the resulting length.
+ * If measuring what they did, then measuring the length of the resulting character array would likely be better.
+ * In short: using this typically means making an assumption about how data in one of our string arrays is or will be segmented,
+ * which can't always be robust since it's possible to violate our default segmentation policy via round tripping the data and injecting irregular segments.
+ * Additionally, using this likely means you will have problems if/when handling embedded objects.
+ * Therefore we might want to reevaluate the code using this, instead of promoting it to a more stable API surface and encouraging use of it.
  *
- * @internal
+ * @alpha
  */
 export function codePointCount(value) {
     // Iterate instead of spreading to avoid allocating an intermediate array.
@@ -30,7 +39,7 @@ export function codePointCount(value) {
  * Returns the number of UTF-16 code units occupied by the first `count` Unicode code points in `value`,
  * starting at UTF-16 index `start`.
  * @remarks
- * Use this to translate {@link PlainText}-space counts (code points) into JavaScript string indices (UTF-16).
+ * Use this to translate {@link PlainText} substring lengths (code points) into JavaScript string lengths (UTF-16).
  * One code point outside the Basic Multilingual Plane (e.g. most emoji) occupies two UTF-16 code units.
  *
  * Validates that the requested `count` code points are fully consumable from `start`; silent truncation
@@ -48,28 +57,31 @@ export function codePointCount(value) {
  * @param start - The UTF-16 index in `value` to start measuring from. Must be in `[0, value.length]`.
  * @param count - The number of Unicode code points to measure. Must be non-negative, and there must
  * be at least `count` code points available in `value` starting at `start`.
+ * @returns The number of UTF-16 code units occupied by the requested code points.
  * @throws A {@link @fluidframework/telemetry-utils#UsageError} if `start` is out of range,
  * `count` is negative, or fewer than `count` code points are available from `start`.
- * @internal
+ *
+ * @privateRemarks
+ * See remarks on {@link codePointCount} regarding the stability of this API and its assumptions about string segmentation.
+ *
+ * @alpha
  */
 export function utf16LengthForCodePoints(value, start, count) {
-    if (start < 0 || start > value.length) {
-        throw new UsageError(`start (${start}) must be within [0, ${value.length}] (value.length).`);
-    }
+    validateIndex(start, value, "utf16LengthForCodePoints", true);
     if (count < 0) {
         throw new UsageError(`count (${count}) must be non-negative.`);
     }
     let utf16 = 0;
     let counted = 0;
-    while (counted < count && start + utf16 < value.length) {
+    while (counted < count) {
+        if (start + utf16 >= value.length) {
+            throw new UsageError(`count (${count}) exceeds the ${counted} code point(s) available from start (${start}) in a value of length ${value.length}.`);
+        }
         // Code points above 0xFFFF are encoded in UTF-16 as a surrogate pair (2 units);
         // everything else takes a single UTF-16 unit.
         utf16 += (value.codePointAt(start + utf16) ?? 0) > 0xffff ? 2 : 1;
         counted++;
     }
-    if (counted !== count) {
-        throw new UsageError(`count (${count}) exceeds the ${counted} code point(s) available from start (${start}) in a value of length ${value.length}.`);
-    }
     return utf16;
 }
 //# sourceMappingURL=codePointUtils.js.map

package/lib/text/codePointUtils.js.map

@@ -1 +1 @@
-{"version":3,"file":"codePointUtils.js","sourceRoot":"","sources":["../../src/text/codePointUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAEtE;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,cAAc,CAAC,KAAa;IAC3C,0EAA0E;IAC1E,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACvB,KAAK,EAAE,CAAC;IACT,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,wBAAwB,CAAC,KAAa,EAAE,KAAa,EAAE,KAAa;IACnF,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;QACvC,MAAM,IAAI,UAAU,CACnB,UAAU,KAAK,wBAAwB,KAAK,CAAC,MAAM,mBAAmB,CACtE,CAAC;IACH,CAAC;IACD,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACf,MAAM,IAAI,UAAU,CAAC,UAAU,KAAK,yBAAyB,CAAC,CAAC;IAChE,CAAC;IACD,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,OAAO,OAAO,GAAG,KAAK,IAAI,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;QACxD,gFAAgF;QAChF,8CAA8C;QAC9C,KAAK,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAClE,OAAO,EAAE,CAAC;IACX,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;QACvB,MAAM,IAAI,UAAU,CACnB,UAAU,KAAK,iBAAiB,OAAO,wCAAwC,KAAK,0BAA0B,KAAK,CAAC,MAAM,GAAG,CAC7H,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\n/**\n * Returns the number of Unicode code points in `value`.\n * @remarks\n * Use this to translate a JavaScript string length (which is in UTF-16 code units) into\n * the atom/code-point space used by {@link PlainText} and {@link FormattedText}.\n *\n * @example\n * ```typescript\n * codePointCount(\"\");     // 0\n * codePointCount(\"abc\");  // 3\n * codePointCount(\"a😀b\"); // 3 — emoji is one code point, but \"a😀b\".length === 4 (UTF-16 surrogate pair)\n * ```\n *\n * @internal\n */\nexport function codePointCount(value: string): number {\n\t// Iterate instead of spreading to avoid allocating an intermediate array.\n\tlet count = 0;\n\tfor (const _ of value) {\n\t\tcount++;\n\t}\n\treturn count;\n}\n\n/**\n * Returns the number of UTF-16 code units occupied by the first `count` Unicode code points in `value`,\n * starting at UTF-16 index `start`.\n * @remarks\n * Use this to translate {@link PlainText}-space counts (code points) into JavaScript string indices (UTF-16).\n * One code point outside the Basic Multilingual Plane (e.g. most emoji) occupies two UTF-16 code units.\n *\n * Validates that the requested `count` code points are fully consumable from `start`; silent truncation\n * would misalign delta offsets applied to strings rather than surface the drift to the caller.\n *\n * @example\n * ```typescript\n * utf16LengthForCodePoints(\"abc\", 0, 3);  // 3 — three single-unit characters\n * utf16LengthForCodePoints(\"a😀b\", 0, 3); // 4 — a (1) + 😀 (2) + b (1)\n * utf16LengthForCodePoints(\"a😀b\", 1, 1); // 2 — just the emoji\n * utf16LengthForCodePoints(\"abc\", 0, 0);  // 0 — no code points requested\n * ```\n *\n * @param value - The string to measure.\n * @param start - The UTF-16 index in `value` to start measuring from. Must be in `[0, value.length]`.\n * @param count - The number of Unicode code points to measure. Must be non-negative, and there must\n * be at least `count` code points available in `value` starting at `start`.\n * @throws A {@link @fluidframework/telemetry-utils#UsageError} if `start` is out of range,\n * `count` is negative, or fewer than `count` code points are available from `start`.\n * @internal\n */\nexport function utf16LengthForCodePoints(value: string, start: number, count: number): number {\n\tif (start < 0 || start > value.length) {\n\t\tthrow new UsageError(\n\t\t\t`start (${start}) must be within [0, ${value.length}] (value.length).`,\n\t\t);\n\t}\n\tif (count < 0) {\n\t\tthrow new UsageError(`count (${count}) must be non-negative.`);\n\t}\n\tlet utf16 = 0;\n\tlet counted = 0;\n\twhile (counted < count && start + utf16 < value.length) {\n\t\t// Code points above 0xFFFF are encoded in UTF-16 as a surrogate pair (2 units);\n\t\t// everything else takes a single UTF-16 unit.\n\t\tutf16 += (value.codePointAt(start + utf16) ?? 0) > 0xffff ? 2 : 1;\n\t\tcounted++;\n\t}\n\tif (counted !== count) {\n\t\tthrow new UsageError(\n\t\t\t`count (${count}) exceeds the ${counted} code point(s) available from start (${start}) in a value of length ${value.length}.`,\n\t\t);\n\t}\n\treturn utf16;\n}\n"]}
+{"version":3,"file":"codePointUtils.js","sourceRoot":"","sources":["../../src/text/codePointUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAEtE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,cAAc,CAAC,KAAa;IAC3C,0EAA0E;IAC1E,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACvB,KAAK,EAAE,CAAC;IACT,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,wBAAwB,CAAC,KAAa,EAAE,KAAa,EAAE,KAAa;IACnF,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,0BAA0B,EAAE,IAAI,CAAC,CAAC;IAC9D,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACf,MAAM,IAAI,UAAU,CAAC,UAAU,KAAK,yBAAyB,CAAC,CAAC;IAChE,CAAC;IACD,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,OAAO,OAAO,GAAG,KAAK,EAAE,CAAC;QACxB,IAAI,KAAK,GAAG,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;YACnC,MAAM,IAAI,UAAU,CACnB,UAAU,KAAK,iBAAiB,OAAO,wCAAwC,KAAK,0BAA0B,KAAK,CAAC,MAAM,GAAG,CAC7H,CAAC;QACH,CAAC;QACD,gFAAgF;QAChF,8CAA8C;QAC9C,KAAK,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAClE,OAAO,EAAE,CAAC;IACX,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport { validateIndex } from \"../util/index.js\";\n\n/**\n * Returns the number of Unicode code points in `value`.\n * @remarks\n * Use this to translate a JavaScript string length (which is in UTF-16 code units) into\n * the atom/code-point space used by {@link PlainText} and {@link FormattedText}.\n *\n * @example\n * ```typescript\n * codePointCount(\"\");     // 0\n * codePointCount(\"abc\");  // 3\n * codePointCount(\"a😀b\"); // 3 — emoji is one code point, but \"a😀b\".length === 4 (UTF-16 surrogate pair)\n * ```\n * @privateRemarks\n * Users of this are assuming the segmentation of their string exactly matches what our text utils do.\n * If they are using this to evaluate what they will do, it might be better to just use the text APIs directly, and measure the resulting length.\n * If measuring what they did, then measuring the length of the resulting character array would likely be better.\n * In short: using this typically means making an assumption about how data in one of our string arrays is or will be segmented,\n * which can't always be robust since it's possible to violate our default segmentation policy via round tripping the data and injecting irregular segments.\n * Additionally, using this likely means you will have problems if/when handling embedded objects.\n * Therefore we might want to reevaluate the code using this, instead of promoting it to a more stable API surface and encouraging use of it.\n *\n * @alpha\n */\nexport function codePointCount(value: string): number {\n\t// Iterate instead of spreading to avoid allocating an intermediate array.\n\tlet count = 0;\n\tfor (const _ of value) {\n\t\tcount++;\n\t}\n\treturn count;\n}\n\n/**\n * Returns the number of UTF-16 code units occupied by the first `count` Unicode code points in `value`,\n * starting at UTF-16 index `start`.\n * @remarks\n * Use this to translate {@link PlainText} substring lengths (code points) into JavaScript string lengths (UTF-16).\n * One code point outside the Basic Multilingual Plane (e.g. most emoji) occupies two UTF-16 code units.\n *\n * Validates that the requested `count` code points are fully consumable from `start`; silent truncation\n * would misalign delta offsets applied to strings rather than surface the drift to the caller.\n *\n * @example\n * ```typescript\n * utf16LengthForCodePoints(\"abc\", 0, 3);  // 3 — three single-unit characters\n * utf16LengthForCodePoints(\"a😀b\", 0, 3); // 4 — a (1) + 😀 (2) + b (1)\n * utf16LengthForCodePoints(\"a😀b\", 1, 1); // 2 — just the emoji\n * utf16LengthForCodePoints(\"abc\", 0, 0);  // 0 — no code points requested\n * ```\n *\n * @param value - The string to measure.\n * @param start - The UTF-16 index in `value` to start measuring from. Must be in `[0, value.length]`.\n * @param count - The number of Unicode code points to measure. Must be non-negative, and there must\n * be at least `count` code points available in `value` starting at `start`.\n * @returns The number of UTF-16 code units occupied by the requested code points.\n * @throws A {@link @fluidframework/telemetry-utils#UsageError} if `start` is out of range,\n * `count` is negative, or fewer than `count` code points are available from `start`.\n *\n * @privateRemarks\n * See remarks on {@link codePointCount} regarding the stability of this API and its assumptions about string segmentation.\n *\n * @alpha\n */\nexport function utf16LengthForCodePoints(value: string, start: number, count: number): number {\n\tvalidateIndex(start, value, \"utf16LengthForCodePoints\", true);\n\tif (count < 0) {\n\t\tthrow new UsageError(`count (${count}) must be non-negative.`);\n\t}\n\tlet utf16 = 0;\n\tlet counted = 0;\n\twhile (counted < count) {\n\t\tif (start + utf16 >= value.length) {\n\t\t\tthrow new UsageError(\n\t\t\t\t`count (${count}) exceeds the ${counted} code point(s) available from start (${start}) in a value of length ${value.length}.`,\n\t\t\t);\n\t\t}\n\t\t// Code points above 0xFFFF are encoded in UTF-16 as a surrogate pair (2 units);\n\t\t// everything else takes a single UTF-16 unit.\n\t\tutf16 += (value.codePointAt(start + utf16) ?? 0) > 0xffff ? 2 : 1;\n\t\tcounted++;\n\t}\n\treturn utf16;\n}\n"]}

package/lib/text/textDomain.d.ts

@@ -2,7 +2,7 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import type { ArrayNodeDeltaOp, ArrayNodeTreeChangedDeltaOp, TreeNode, WithType } from "../simple-tree/index.js";
+import type { ArrayPlaceAnchor, ArrayNodeDeltaOp, ArrayNodeTreeChangedDeltaOp, TreeNode, WithType } from "../simple-tree/index.js";
 import type { NodeKind, TreeNodeSchema } from "../simple-tree/index.js";
 /**
  * Enables or disables expensive debug assertions for formatted text.
@@ -249,6 +249,12 @@ export declare namespace PlainText {
          * corresponds to two UTF-16 code units — convert before using the counts as string indices.
          */
         onCharactersChanged(callback: (ops: readonly TextOp[] | undefined) => void): () => void;
+        /**
+         * Creates an anchor that tracks an insertion point at `index` as the text is edited.
+         * @param index - The character index of the insertion point to track.
+         * @returns An anchor whose index updates as the text is edited. Call {@link ArrayPlaceAnchor.dispose} when it is no longer needed.
+         */
+        createInsertionAnchor(index: number): ArrayPlaceAnchor;
     }
     /**
      * Schema for a {@link PlainText.(Tree:variable)} node.

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;AAqBH,OAAO,KAAK,EACX,gBAAgB,EAChB,2BAA2B,EAC3B,QAAQ,EACR,QAAQ,EAER,MAAM,yBAAyB,CAAC;AAIjC,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAOxE;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAEnE;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAAC,SAAS,EAAE,MAAM,IAAI,GAAG,MAAM,GAAG,IAAI,CAEtF;AAsID;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,CAKpE;AAsBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,6BAA6B,CAC5C,KAAK,EAAE,SAAS,CAAC,gBAAgB,GAAG,2BAA2B,CAAC,EAAE,GAAG,SAAS,EAC9E,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,EACnD,QAAQ,EAAE,CAAC,GAAG,EAAE,SAAS,SAAS,CAAC,MAAM,EAAE,GAAG,SAAS,KAAK,IAAI,GAC9D,IAAI,CAqCN;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,yBAAiB,SAAS,CAAC;IAC1B;;;;OAIG;IACH,UAAiB,YAAY;QAC5B;;WAEG;QACH,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;QACxB;;WAEG;QACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB;;;;;;;WAOG;QACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;KACrC;IAED;;;;;;OAMG;IACH,UAAiB,YAAY;QAC5B;;WAEG;QACH,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;QACxB;;WAEG;QACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;KACtB;IAED;;;;OAIG;IACH,UAAiB,YAAY;QAC5B;;WAEG;QACH,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;QACxB;;WAEG;QACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;KACvB;IAED;;;OAGG;IACH,KAAY,MAAM,GAAG,YAAY,GAAG,YAAY,GAAG,YAAY,CAAC;IAEhE;;;OAGG;IACH,UAAiB,OAAO;QACvB;;;WAGG;QACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;KAChC;IAED;;;;;;;;;;;;;;;;;OAiBG;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;QAEhF;;;;;;;;;;;;;WAaG;QACH,mBAAmB,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;KACxF;IAED;;;;;OAKG;IACI,MAAM,IAAI,oKAAmD,CAAC;IAErE;;;;;OAKG;IACH,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":"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"}

package/lib/text/textDomain.js

@@ -2,16 +2,14 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-var _TextNode_instances, _TextNode_fullString_reference, _TextNode_charactersCopy_reference;
-import { __classPrivateFieldGet } from "tslib";
 import { compareArrays, debugAssert } from "@fluidframework/core-utils/internal";
 import { buildFunc, exposeMethodsSymbol,
 // eslint-disable-next-line import-x/no-internal-modules
  } from "@fluidframework/type-factory/alpha";
 import { typeFactory as tf } from "@fluidframework/type-factory/internal";
 import { EmptyKey, mapCursorField } from "../core/index.js";
-import { TreeAlpha } from "../shared-tree/index.js";
-import { eraseSchemaDetails, getInnerNode, SchemaFactory, SchemaFactoryAlpha, TreeArrayNode, } from "../simple-tree/index.js";
+import { createArrayInsertionAnchor, eraseSchemaDetails, getInnerNode, SchemaFactory, SchemaFactoryAlpha, TreeArrayNode, } from "../simple-tree/index.js";
+import { TreeBeta } from "../shared-tree/index.js";
 /**
  * Enables expensive debug assertions for formatted text.
  */
@@ -36,11 +34,7 @@ const sf = new SchemaFactoryAlpha("com.fluidframework.text");
 class TextNode extends sf.object("Text", {
     content: SchemaFactory.required([() => StringArray], { key: EmptyKey }),
 }) {
-    constructor() {
-        super(...arguments);
-        _TextNode_instances.add(this);
-    }
-    static [(_TextNode_instances = new WeakSet(), exposeMethodsSymbol)](methods) {
+    static [exposeMethodsSymbol](methods) {
         methods.exposeMethod(TextNode, "insertAt", buildFunc({
             description: "Insert characters into the text at the given character index (Unicode code points).",
             returns: tf.void(),
@@ -79,17 +73,32 @@ class TextNode extends sf.object("Text", {
     }
     charactersCopy() {
         const result = this.content.charactersCopy();
-        expensiveInternalValidationAssert(() => compareArrays(result, __classPrivateFieldGet(this, _TextNode_instances, "m", _TextNode_charactersCopy_reference).call(this)) ||
+        expensiveInternalValidationAssert(() => compareArrays(result, this.#charactersCopy_reference()) ||
             "invalid charactersCopy optimizations");
         return result;
     }
     fullString() {
         const result = this.content.fullString();
-        expensiveInternalValidationAssert(() => result === __classPrivateFieldGet(this, _TextNode_instances, "m", _TextNode_fullString_reference).call(this) || "invalid fullString optimizations");
+        expensiveInternalValidationAssert(() => 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];
+    }
     onCharactersChanged(callback) {
-        return TreeAlpha.on(this.content, "nodeChanged", ({ delta }) => processCharactersChangedDelta(delta, (i) => this.content[i], callback));
+        return TreeBeta.on(this.content, "nodeChanged", ({ delta }) => processCharactersChangedDelta(delta, (i) => this.content[i], callback));
+    }
+    createInsertionAnchor(index) {
+        return createArrayInsertionAnchor(this.content, index);
     }
     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,
@@ -98,11 +107,6 @@ class TextNode extends sf.object("Text", {
         return new TextNode({ content: [...charactersFromString(value)] });
     }
 }
-_TextNode_fullString_reference = function _TextNode_fullString_reference() {
-    return this.content.join("");
-}, _TextNode_charactersCopy_reference = function _TextNode_charactersCopy_reference() {
-    return [...this.content];
-};
 /**
  * Interpret a string as an iterable of characters.
  * @remarks

package/lib/text/textDomain.js.map

@@ -1 +1 @@
-{"version":3,"file":"textDomain.js","sourceRoot":"","sources":["../../src/text/textDomain.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 { compareArrays, debugAssert } from \"@fluidframework/core-utils/internal\";\nimport {\n\tbuildFunc,\n\texposeMethodsSymbol,\n\ttype ExposedMethods,\n\ttype IExposedMethods,\n\t// eslint-disable-next-line import-x/no-internal-modules\n} from \"@fluidframework/type-factory/alpha\";\nimport { typeFactory as tf } from \"@fluidframework/type-factory/internal\";\n\nimport { EmptyKey, mapCursorField, type ITreeCursorSynchronous } from \"../core/index.js\";\nimport { TreeAlpha } from \"../shared-tree/index.js\";\nimport {\n\teraseSchemaDetails,\n\tgetInnerNode,\n\tSchemaFactory,\n\tSchemaFactoryAlpha,\n\tTreeArrayNode,\n} from \"../simple-tree/index.js\";\nimport type {\n\tArrayNodeDeltaOp,\n\tArrayNodeTreeChangedDeltaOp,\n\tTreeNode,\n\tWithType,\n\t// eslint-disable-next-line import-x/no-duplicates\n} 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\n/**\n * Enables expensive debug assertions for formatted text.\n */\nlet enableTextExpensiveDebugAsserts = false;\n\n/**\n * Enables or disables expensive debug assertions for formatted text.\n * @remarks\n * These should remain disabled except when testing implementation details of this code.\n */\nexport function setEnableExpensiveDebugAsserts(value: boolean): void {\n\tenableTextExpensiveDebugAsserts = value;\n}\n\n/**\n * Runs `condition` as a {@link debugAssert} only when {@link enableTextExpensiveDebugAsserts} is enabled.\n * @remarks\n * Like all {@link debugAssert}s, this is compiled out of production builds, so `condition` is never evaluated there.\n */\nexport function expensiveInternalValidationAssert(condition: () => true | string): void {\n\tdebugAssert(() => !enableTextExpensiveDebugAsserts || condition());\n}\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 PlainText.Members, IExposedMethods\n{\n\tpublic static [exposeMethodsSymbol](methods: ExposedMethods): void {\n\t\tmethods.exposeMethod(\n\t\t\tTextNode,\n\t\t\t\"insertAt\",\n\t\t\tbuildFunc(\n\t\t\t\t{\n\t\t\t\t\tdescription:\n\t\t\t\t\t\t\"Insert characters into the text at the given character index (Unicode code points).\",\n\t\t\t\t\treturns: tf.void(),\n\t\t\t\t},\n\t\t\t\t[\"index\", tf.number()],\n\t\t\t\t[\"additionalCharacters\", tf.string()],\n\t\t\t),\n\t\t);\n\t\tmethods.exposeMethod(\n\t\t\tTextNode,\n\t\t\t\"removeRange\",\n\t\t\tbuildFunc(\n\t\t\t\t{\n\t\t\t\t\tdescription:\n\t\t\t\t\t\t\"Remove a range of characters from the text by character index (Unicode code points). startIndex defaults to 0 and endIndex defaults to the length of the text.\",\n\t\t\t\t\treturns: tf.void(),\n\t\t\t\t},\n\t\t\t\t[\"startIndex\", tf.union([tf.number(), tf.undefined()])],\n\t\t\t\t[\"endIndex\", tf.union([tf.number(), tf.undefined()])],\n\t\t\t),\n\t\t);\n\t\tmethods.exposeMethod(\n\t\t\tTextNode,\n\t\t\t\"fullString\",\n\t\t\tbuildFunc({\n\t\t\t\tdescription: \"Return a copy of this text node's content as a string.\",\n\t\t\t\treturns: tf.string(),\n\t\t\t}),\n\t\t);\n\t\tmethods.exposeMethod(\n\t\t\tTextNode,\n\t\t\t\"characterCount\",\n\t\t\tbuildFunc({\n\t\t\t\tdescription:\n\t\t\t\t\t\"Gets the number of characters (Unicode code points) currently in the text. Joined emojis and other grapheme clusters count as multiple characters.\",\n\t\t\t\treturns: tf.number(),\n\t\t\t}),\n\t\t);\n\t\tmethods.exposeMethod(\n\t\t\tTextNode,\n\t\t\t\"charactersCopy\",\n\t\t\tbuildFunc({\n\t\t\t\tdescription:\n\t\t\t\t\t\"Returns all characters in the text as an array, where each element is a single Unicode code point. Joined emojis and other grapheme clusters are split into separate elements.\",\n\t\t\t\treturns: tf.array(tf.string()),\n\t\t\t}),\n\t\t);\n\t}\n\n\tpublic [exposeMethodsSymbol](methods: ExposedMethods): void {\n\t\tTextNode[exposeMethodsSymbol](methods);\n\t}\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\texpensiveInternalValidationAssert(\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\texpensiveInternalValidationAssert(\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\t#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\t#charactersCopy_reference(): string[] {\n\t\treturn [...this.content];\n\t}\n\n\tpublic onCharactersChanged(\n\t\tcallback: (ops: readonly PlainText.TextOp[] | undefined) => void,\n\t): () => void {\n\t\treturn TreeAlpha.on(this.content, \"nodeChanged\", ({ delta }) =>\n\t\t\tprocessCharactersChangedDelta(delta, (i) => this.content[i], callback),\n\t\t);\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 * Processes an array-node delta into a {@link PlainText.TextOp}[] and calls `callback`.\n * @remarks\n * Shared by both the plain `onCharactersChanged` (from `nodeChanged`) and formatted `onContentChanged`\n * (from `treeChanged`) implementations.\n * @param delta - The raw array-node delta, or `undefined` when no delta is available.\n * When retain ops carry `subtreeChanged` (i.e. delta comes from a `treeChanged` event), the emitted\n * retain ops include an explicit `formattingChanged: boolean`. Otherwise `formattingChanged` is omitted.\n * @param getCharacter - Returns the character string at the given array index in the **post-edit** tree.\n * Only invoked for insert ops, where it must read the inserted character at the given index of the tree\n * after the edit has been applied. Passing an accessor that reads pre-edit content will silently produce wrong text.\n * Return `undefined` if the tree is out of sync with the delta; this triggers a full-reread fallback.\n * @param callback - The user-supplied callback to invoke with the translated ops.\n */\nexport function processCharactersChangedDelta(\n\tdelta: readonly (ArrayNodeDeltaOp | ArrayNodeTreeChangedDeltaOp)[] | undefined,\n\tgetCharacter: (index: number) => string | undefined,\n\tcallback: (ops: readonly PlainText.TextOp[] | undefined) => void,\n): void {\n\tif (delta === undefined) {\n\t\tcallback(undefined);\n\t\treturn;\n\t}\n\tlet readPosition = 0;\n\tconst ops: PlainText.TextOp[] = [];\n\tfor (const op of delta) {\n\t\tif (op.type === \"retain\") {\n\t\t\t// `subtreeChanged` is only present on retain ops from `treeChanged` deltas.\n\t\t\tops.push(\n\t\t\t\t\"subtreeChanged\" in op\n\t\t\t\t\t? { type: \"retain\", count: op.count, formattingChanged: op.subtreeChanged === true }\n\t\t\t\t\t: { type: \"retain\", count: op.count },\n\t\t\t);\n\t\t\treadPosition += op.count;\n\t\t} else if (op.type === \"insert\") {\n\t\t\t// Accumulate into an array and join at the end to keep this O(n) for large inserts\n\t\t\t// (paste of long text) instead of O(n^2) from repeated string concatenation.\n\t\t\tconst characters: string[] = [];\n\t\t\tfor (let i = 0; i < op.count; i++) {\n\t\t\t\tconst character = getCharacter(readPosition);\n\t\t\t\tif (character === undefined) {\n\t\t\t\t\t// Tree is out of sync with the delta — fall back to full re-read.\n\t\t\t\t\tcallback(undefined);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tcharacters.push(character);\n\t\t\t\treadPosition++;\n\t\t\t}\n\t\t\tops.push({ type: \"insert\", text: characters.join(\"\") });\n\t\t} else {\n\t\t\t// Construct explicit remove op so internal fields on the source op don't leak.\n\t\t\tops.push({ type: \"remove\", count: op.count });\n\t\t}\n\t}\n\tcallback(ops);\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 PlainText {\n\t/**\n\t * A retain op in a character-level delta — a span of unchanged characters that the consumer should skip over.\n\t * @sealed\n\t * @alpha\n\t */\n\texport interface TextRetainOp {\n\t\t/**\n\t\t * Discriminator identifying this op as a retain.\n\t\t */\n\t\treadonly type: \"retain\";\n\t\t/**\n\t\t * The number of Unicode code points to retain.\n\t\t */\n\t\treadonly count: number;\n\t\t/**\n\t\t * Whether at least one character in the retained range had a deep change.\n\t\t * @remarks\n\t\t * Present only on retain ops delivered by {@link @fluidframework/tree#FormattedText.Members.onContentChanged};\n\t\t * always absent on retain ops delivered by {@link PlainText.Members.onCharactersChanged}.\n\t\t * When present, `true` indicates the retained range contained a formatting property update\n\t\t * or an atom content edit; `false` indicates no deep change.\n\t\t */\n\t\treadonly formattingChanged?: boolean;\n\t}\n\n\t/**\n\t * An insert op in a character-level delta — characters newly added to the text.\n\t * @remarks\n\t * Carries the inserted text as a single string, which is more convenient for consumers than individual characters.\n\t * @sealed\n\t * @alpha\n\t */\n\texport interface TextInsertOp {\n\t\t/**\n\t\t * Discriminator identifying this op as an insert.\n\t\t */\n\t\treadonly type: \"insert\";\n\t\t/**\n\t\t * The newly inserted characters, concatenated into a single string.\n\t\t */\n\t\treadonly text: string;\n\t}\n\n\t/**\n\t * A remove op in a character-level delta — a span of characters that has been deleted from the text.\n\t * @sealed\n\t * @alpha\n\t */\n\texport interface TextRemoveOp {\n\t\t/**\n\t\t * Discriminator identifying this op as a remove.\n\t\t */\n\t\treadonly type: \"remove\";\n\t\t/**\n\t\t * The number of Unicode code points removed.\n\t\t */\n\t\treadonly count: number;\n\t}\n\n\t/**\n\t * A single operation in a character-level delta describing an insert, remove, or retain of text.\n\t * @alpha\n\t */\n\texport type TextOp = TextRetainOp | TextInsertOp | TextRemoveOp;\n\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 PlainText.(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 PlainText.Statics.fromString} for construction.\n\t * @see {@link PlainText.(Tree:type)} for schema.\n\t * @sealed\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 PlainText.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 PlainText.Members.characters}.\n\t\t * This is not the length of the string returned by {@link PlainText.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 PlainText.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\n\t\t/**\n\t\t * Subscribe to shallow character-level changes on this text node — inserts and removes only.\n\t\t * @param callback - Called after each change with a sequence of {@link PlainText.TextOp}s describing what changed,\n\t\t * or `undefined` when a delta could not be computed (e.g. during a schema upgrade).\n\t\t * @returns A cleanup function that unsubscribes the callback when called.\n\t\t * @remarks\n\t\t * Only fires on shallow changes — inserts and removes.\n\t\t * It does not fire on deep changes such as formatting property updates on existing characters.\n\t\t * For formatted text, use {@link @fluidframework/tree#FormattedText.Members.onContentChanged} to also receive deep changes.\n\t\t *\n\t\t * All counts in the delivered ops are in Unicode code points, not UTF-16 code units.\n\t\t * For characters outside the Basic Multilingual Plane (e.g. emoji), one code point\n\t\t * corresponds to two UTF-16 code units — convert before using the counts as string indices.\n\t\t */\n\t\tonCharactersChanged(callback: (ops: readonly TextOp[] | undefined) => void): () => void;\n\t}\n\n\t/**\n\t * Schema for a {@link PlainText.(Tree:variable)} node.\n\t * @remarks\n\t * See {@link PlainText.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 PlainText.(Tree:type)} schema exposing the {@link PlainText.Members} API.\n\t * @remarks\n\t * Create using {@link PlainText.Statics.fromString}.\n\t * @alpha\n\t */\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":"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","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\";\nimport {\n\tbuildFunc,\n\texposeMethodsSymbol,\n\ttype ExposedMethods,\n\ttype IExposedMethods,\n\t// eslint-disable-next-line import-x/no-internal-modules\n} from \"@fluidframework/type-factory/alpha\";\nimport { typeFactory as tf } from \"@fluidframework/type-factory/internal\";\n\nimport { EmptyKey, mapCursorField, type ITreeCursorSynchronous } from \"../core/index.js\";\nimport {\n\tcreateArrayInsertionAnchor,\n\teraseSchemaDetails,\n\tgetInnerNode,\n\tSchemaFactory,\n\tSchemaFactoryAlpha,\n\tTreeArrayNode,\n} from \"../simple-tree/index.js\";\nimport { TreeBeta } from \"../shared-tree/index.js\";\nimport type {\n\tArrayPlaceAnchor,\n\tArrayNodeDeltaOp,\n\tArrayNodeTreeChangedDeltaOp,\n\tTreeNode,\n\tWithType,\n\t// eslint-disable-next-line import-x/no-duplicates\n} 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\n/**\n * Enables expensive debug assertions for formatted text.\n */\nlet enableTextExpensiveDebugAsserts = false;\n\n/**\n * Enables or disables expensive debug assertions for formatted text.\n * @remarks\n * These should remain disabled except when testing implementation details of this code.\n */\nexport function setEnableExpensiveDebugAsserts(value: boolean): void {\n\tenableTextExpensiveDebugAsserts = value;\n}\n\n/**\n * Runs `condition` as a {@link debugAssert} only when {@link enableTextExpensiveDebugAsserts} is enabled.\n * @remarks\n * Like all {@link debugAssert}s, this is compiled out of production builds, so `condition` is never evaluated there.\n */\nexport function expensiveInternalValidationAssert(condition: () => true | string): void {\n\tdebugAssert(() => !enableTextExpensiveDebugAsserts || condition());\n}\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 PlainText.Members, IExposedMethods\n{\n\tpublic static [exposeMethodsSymbol](methods: ExposedMethods): void {\n\t\tmethods.exposeMethod(\n\t\t\tTextNode,\n\t\t\t\"insertAt\",\n\t\t\tbuildFunc(\n\t\t\t\t{\n\t\t\t\t\tdescription:\n\t\t\t\t\t\t\"Insert characters into the text at the given character index (Unicode code points).\",\n\t\t\t\t\treturns: tf.void(),\n\t\t\t\t},\n\t\t\t\t[\"index\", tf.number()],\n\t\t\t\t[\"additionalCharacters\", tf.string()],\n\t\t\t),\n\t\t);\n\t\tmethods.exposeMethod(\n\t\t\tTextNode,\n\t\t\t\"removeRange\",\n\t\t\tbuildFunc(\n\t\t\t\t{\n\t\t\t\t\tdescription:\n\t\t\t\t\t\t\"Remove a range of characters from the text by character index (Unicode code points). startIndex defaults to 0 and endIndex defaults to the length of the text.\",\n\t\t\t\t\treturns: tf.void(),\n\t\t\t\t},\n\t\t\t\t[\"startIndex\", tf.union([tf.number(), tf.undefined()])],\n\t\t\t\t[\"endIndex\", tf.union([tf.number(), tf.undefined()])],\n\t\t\t),\n\t\t);\n\t\tmethods.exposeMethod(\n\t\t\tTextNode,\n\t\t\t\"fullString\",\n\t\t\tbuildFunc({\n\t\t\t\tdescription: \"Return a copy of this text node's content as a string.\",\n\t\t\t\treturns: tf.string(),\n\t\t\t}),\n\t\t);\n\t\tmethods.exposeMethod(\n\t\t\tTextNode,\n\t\t\t\"characterCount\",\n\t\t\tbuildFunc({\n\t\t\t\tdescription:\n\t\t\t\t\t\"Gets the number of characters (Unicode code points) currently in the text. Joined emojis and other grapheme clusters count as multiple characters.\",\n\t\t\t\treturns: tf.number(),\n\t\t\t}),\n\t\t);\n\t\tmethods.exposeMethod(\n\t\t\tTextNode,\n\t\t\t\"charactersCopy\",\n\t\t\tbuildFunc({\n\t\t\t\tdescription:\n\t\t\t\t\t\"Returns all characters in the text as an array, where each element is a single Unicode code point. Joined emojis and other grapheme clusters are split into separate elements.\",\n\t\t\t\treturns: tf.array(tf.string()),\n\t\t\t}),\n\t\t);\n\t}\n\n\tpublic [exposeMethodsSymbol](methods: ExposedMethods): void {\n\t\tTextNode[exposeMethodsSymbol](methods);\n\t}\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\texpensiveInternalValidationAssert(\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\texpensiveInternalValidationAssert(\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\t#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\t#charactersCopy_reference(): string[] {\n\t\treturn [...this.content];\n\t}\n\n\tpublic onCharactersChanged(\n\t\tcallback: (ops: readonly PlainText.TextOp[] | undefined) => void,\n\t): () => void {\n\t\treturn TreeBeta.on(this.content, \"nodeChanged\", ({ delta }) =>\n\t\t\tprocessCharactersChangedDelta(delta, (i) => this.content[i], callback),\n\t\t);\n\t}\n\n\tpublic createInsertionAnchor(index: number): ArrayPlaceAnchor {\n\t\treturn createArrayInsertionAnchor(this.content, index);\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 * Processes an array-node delta into a {@link PlainText.TextOp}[] and calls `callback`.\n * @remarks\n * Shared by both the plain `onCharactersChanged` (from `nodeChanged`) and formatted `onContentChanged`\n * (from `treeChanged`) implementations.\n * @param delta - The raw array-node delta, or `undefined` when no delta is available.\n * When retain ops carry `subtreeChanged` (i.e. delta comes from a `treeChanged` event), the emitted\n * retain ops include an explicit `formattingChanged: boolean`. Otherwise `formattingChanged` is omitted.\n * @param getCharacter - Returns the character string at the given array index in the **post-edit** tree.\n * Only invoked for insert ops, where it must read the inserted character at the given index of the tree\n * after the edit has been applied. Passing an accessor that reads pre-edit content will silently produce wrong text.\n * Return `undefined` if the tree is out of sync with the delta; this triggers a full-reread fallback.\n * @param callback - The user-supplied callback to invoke with the translated ops.\n */\nexport function processCharactersChangedDelta(\n\tdelta: readonly (ArrayNodeDeltaOp | ArrayNodeTreeChangedDeltaOp)[] | undefined,\n\tgetCharacter: (index: number) => string | undefined,\n\tcallback: (ops: readonly PlainText.TextOp[] | undefined) => void,\n): void {\n\tif (delta === undefined) {\n\t\tcallback(undefined);\n\t\treturn;\n\t}\n\tlet readPosition = 0;\n\tconst ops: PlainText.TextOp[] = [];\n\tfor (const op of delta) {\n\t\tif (op.type === \"retain\") {\n\t\t\t// `subtreeChanged` is only present on retain ops from `treeChanged` deltas.\n\t\t\tops.push(\n\t\t\t\t\"subtreeChanged\" in op\n\t\t\t\t\t? { type: \"retain\", count: op.count, formattingChanged: op.subtreeChanged === true }\n\t\t\t\t\t: { type: \"retain\", count: op.count },\n\t\t\t);\n\t\t\treadPosition += op.count;\n\t\t} else if (op.type === \"insert\") {\n\t\t\t// Accumulate into an array and join at the end to keep this O(n) for large inserts\n\t\t\t// (paste of long text) instead of O(n^2) from repeated string concatenation.\n\t\t\tconst characters: string[] = [];\n\t\t\tfor (let i = 0; i < op.count; i++) {\n\t\t\t\tconst character = getCharacter(readPosition);\n\t\t\t\tif (character === undefined) {\n\t\t\t\t\t// Tree is out of sync with the delta — fall back to full re-read.\n\t\t\t\t\tcallback(undefined);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tcharacters.push(character);\n\t\t\t\treadPosition++;\n\t\t\t}\n\t\t\tops.push({ type: \"insert\", text: characters.join(\"\") });\n\t\t} else {\n\t\t\t// Construct explicit remove op so internal fields on the source op don't leak.\n\t\t\tops.push({ type: \"remove\", count: op.count });\n\t\t}\n\t}\n\tcallback(ops);\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 PlainText {\n\t/**\n\t * A retain op in a character-level delta — a span of unchanged characters that the consumer should skip over.\n\t * @sealed\n\t * @alpha\n\t */\n\texport interface TextRetainOp {\n\t\t/**\n\t\t * Discriminator identifying this op as a retain.\n\t\t */\n\t\treadonly type: \"retain\";\n\t\t/**\n\t\t * The number of Unicode code points to retain.\n\t\t */\n\t\treadonly count: number;\n\t\t/**\n\t\t * Whether at least one character in the retained range had a deep change.\n\t\t * @remarks\n\t\t * Present only on retain ops delivered by {@link @fluidframework/tree#FormattedText.Members.onContentChanged};\n\t\t * always absent on retain ops delivered by {@link PlainText.Members.onCharactersChanged}.\n\t\t * When present, `true` indicates the retained range contained a formatting property update\n\t\t * or an atom content edit; `false` indicates no deep change.\n\t\t */\n\t\treadonly formattingChanged?: boolean;\n\t}\n\n\t/**\n\t * An insert op in a character-level delta — characters newly added to the text.\n\t * @remarks\n\t * Carries the inserted text as a single string, which is more convenient for consumers than individual characters.\n\t * @sealed\n\t * @alpha\n\t */\n\texport interface TextInsertOp {\n\t\t/**\n\t\t * Discriminator identifying this op as an insert.\n\t\t */\n\t\treadonly type: \"insert\";\n\t\t/**\n\t\t * The newly inserted characters, concatenated into a single string.\n\t\t */\n\t\treadonly text: string;\n\t}\n\n\t/**\n\t * A remove op in a character-level delta — a span of characters that has been deleted from the text.\n\t * @sealed\n\t * @alpha\n\t */\n\texport interface TextRemoveOp {\n\t\t/**\n\t\t * Discriminator identifying this op as a remove.\n\t\t */\n\t\treadonly type: \"remove\";\n\t\t/**\n\t\t * The number of Unicode code points removed.\n\t\t */\n\t\treadonly count: number;\n\t}\n\n\t/**\n\t * A single operation in a character-level delta describing an insert, remove, or retain of text.\n\t * @alpha\n\t */\n\texport type TextOp = TextRetainOp | TextInsertOp | TextRemoveOp;\n\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 PlainText.(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 PlainText.Statics.fromString} for construction.\n\t * @see {@link PlainText.(Tree:type)} for schema.\n\t * @sealed\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 PlainText.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 PlainText.Members.characters}.\n\t\t * This is not the length of the string returned by {@link PlainText.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 PlainText.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\n\t\t/**\n\t\t * Subscribe to shallow character-level changes on this text node — inserts and removes only.\n\t\t * @param callback - Called after each change with a sequence of {@link PlainText.TextOp}s describing what changed,\n\t\t * or `undefined` when a delta could not be computed (e.g. during a schema upgrade).\n\t\t * @returns A cleanup function that unsubscribes the callback when called.\n\t\t * @remarks\n\t\t * Only fires on shallow changes — inserts and removes.\n\t\t * It does not fire on deep changes such as formatting property updates on existing characters.\n\t\t * For formatted text, use {@link @fluidframework/tree#FormattedText.Members.onContentChanged} to also receive deep changes.\n\t\t *\n\t\t * All counts in the delivered ops are in Unicode code points, not UTF-16 code units.\n\t\t * For characters outside the Basic Multilingual Plane (e.g. emoji), one code point\n\t\t * corresponds to two UTF-16 code units — convert before using the counts as string indices.\n\t\t */\n\t\tonCharactersChanged(callback: (ops: readonly TextOp[] | undefined) => void): () => void;\n\n\t\t/**\n\t\t * Creates an anchor that tracks an insertion point at `index` as the text is edited.\n\t\t * @param index - The character index of the insertion point to track.\n\t\t * @returns An anchor whose index updates as the text is edited. Call {@link ArrayPlaceAnchor.dispose} when it is no longer needed.\n\t\t */\n\t\tcreateInsertionAnchor(index: number): ArrayPlaceAnchor;\n\t}\n\n\t/**\n\t * Schema for a {@link PlainText.(Tree:variable)} node.\n\t * @remarks\n\t * See {@link PlainText.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 PlainText.(Tree:type)} schema exposing the {@link PlainText.Members} API.\n\t * @remarks\n\t * Create using {@link PlainText.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.map

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

package/lib/text/textDomainFormatted.js

@@ -2,13 +2,12 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { __classPrivateFieldGet } from "tslib";
 import { assert, compareArrays, debugAssert, fail } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { EmptyKey, forEachNodeSubsequence, } from "../core/index.js";
 import { currentObserver, buildNodeComparator } from "../feature-libraries/index.js";
-import { TreeAlpha, Tree as TreeStatic } from "../shared-tree/index.js";
-import { getInnerNode, SchemaFactory, SchemaFactoryAlpha, TreeArrayNode, TreeBeta, createCustomizedFluidFrameworkScopedFactory, eraseSchemaDetails, isObjectNodeSchema, eraseSchemaDetailsSubclassable, } from "../simple-tree/index.js";
+import { TreeAlpha, Tree as TreeStatic, TreeBeta } from "../shared-tree/index.js";
+import { createArrayInsertionAnchor, getInnerNode, SchemaFactory, SchemaFactoryAlpha, TreeArrayNode, createCustomizedFluidFrameworkScopedFactory, eraseSchemaDetails, isObjectNodeSchema, eraseSchemaDetailsSubclassable, } from "../simple-tree/index.js";
 import { brand, mapIterable, oneFromIterable, validateIndex, validateIndexRange, } from "../util/index.js";
 import { charactersFromString, expensiveInternalValidationAssert, processCharactersChangedDelta, } from "./textDomain.js";
 /**
@@ -91,7 +90,6 @@ export var FormattedText;
      * TODO: The choice to always include the built-in {@link FormattedText.(StringTextAtom:variable)} is a design decision that should be re-evaluated before stabilizing.
      */
     function createSchema(inputSchemaFactory, formatSchema, extraAtoms, defaultFormatInsertable) {
-        var _TextNode_instances, _TextNode_fullString_reference, _TextNode_charactersCopy_reference, _TextNode_editRange;
         const atoms = [FormattedText.StringTextAtom, ...extraAtoms];
         const sf = createFormattedScopedFactory(inputSchemaFactory);
         const defaultFormat = TreeBeta.create(formatSchema, defaultFormatInsertable);
@@ -113,10 +111,6 @@ export var FormattedText;
         class TextNode extends sf.object("Text", {
             content: SchemaFactory.required([() => StringArray], { key: EmptyKey }),
         }) {
-            constructor() {
-                super(...arguments);
-                _TextNode_instances.add(this);
-            }
             insertAt(index, additionalCharacters, format) {
                 const newAtoms = typeof additionalCharacters === "string"
                     ? stringTextAtomsFromString(additionalCharacters)
@@ -132,7 +126,7 @@ export var FormattedText;
             }
             charactersCopy() {
                 const result = this.content.charactersCopy();
-                expensiveInternalValidationAssert(() => compareArrays(result, __classPrivateFieldGet(this, _TextNode_instances, "m", _TextNode_charactersCopy_reference).call(this)) ||
+                expensiveInternalValidationAssert(() => compareArrays(result, this.#charactersCopy_reference()) ||
                     "invalid charactersCopy optimizations");
                 return result;
             }
@@ -141,9 +135,21 @@ export var FormattedText;
             }
             fullString() {
                 const result = this.content.fullString();
-                expensiveInternalValidationAssert(() => result === __classPrivateFieldGet(this, _TextNode_instances, "m", _TextNode_fullString_reference).call(this) || "invalid fullString optimizations");
+                expensiveInternalValidationAssert(() => 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) {
                 const formatNode = getFormatNode(format);
                 // Use `this` rather than `TextNode` so the more derived schema class is constructed when using this as a static on a subclass.
@@ -170,7 +176,7 @@ export var FormattedText;
                     assert(typeof key === "string", 0xcc8 /* Object.entries returned a non-string key. */);
                     return [key, value];
                 });
-                __classPrivateFieldGet(this, _TextNode_instances, "m", _TextNode_editRange).call(this, start, end, "FormattedText.formatRange", (atom) => {
+                this.#editRange(start, end, "FormattedText.formatRange", (atom) => {
                     const formatNode = atom.format;
                     const atomFormatSchema = TreeStatic.schema(formatNode);
                     if (!isObjectNodeSchema(atomFormatSchema)) {
@@ -190,10 +196,30 @@ export var FormattedText;
             }
             reformat(start, end, format) {
                 const node = getFormatNode(format);
-                __classPrivateFieldGet(this, _TextNode_instances, "m", _TextNode_editRange).call(this, start, end, "FormattedText.reformat", (atom) => {
+                this.#editRange(start, end, "FormattedText.reformat", (atom) => {
                     atom.format = cloneFormat(node);
                 });
             }
+            /**
+             * Map an edit over a range of atoms, validating the range and running the edits in a transaction.
+             * @remarks
+             * This is not exposed in the API since this approach will have to be replaced when formatting is optimized,
+             * so we don't want users to directly depend on this un-optimizable layer.
+             */
+            #editRange(start, end, method, edit) {
+                const formatStart = start ?? 0;
+                validateIndex(formatStart, this.content, method, true);
+                const formatEnd = Math.min(this.content.length, end ?? this.content.length);
+                validateIndexRange(formatStart, formatEnd, this.content, method);
+                TreeAlpha.context(this).runTransaction(() => {
+                    for (let i = formatStart; i < formatEnd; i++) {
+                        const atom = this.content[i];
+                        // Range validated above, so this should never fail.
+                        assert(atom !== undefined, 0xd08 /* Index out of bounds while formatting text range. */);
+                        edit(atom);
+                    }
+                });
+            }
             /**
              * Returns the {@link  FormattedText.TextAtom.content} at the given atom index, or `undefined` if out of bounds.
              */
@@ -204,10 +230,13 @@ export var FormattedText;
                 return atom.content.content;
             }
             onCharactersChanged(callback) {
-                return TreeAlpha.on(this.content, "nodeChanged", ({ delta }) => processCharactersChangedDelta(delta, (index) => this.getAtomCharacterAt(index), callback));
+                return TreeBeta.on(this.content, "nodeChanged", ({ delta }) => processCharactersChangedDelta(delta, (index) => this.getAtomCharacterAt(index), callback));
+            }
+            createInsertionAnchor(index) {
+                return createArrayInsertionAnchor(this.content, index);
             }
             onContentChanged(callback) {
-                return TreeAlpha.on(this.content, "treeChanged", ({ delta }) => processCharactersChangedDelta(delta, (index) => this.getAtomCharacterAt(index), callback));
+                return TreeBeta.on(this.content, "treeChanged", ({ delta }) => processCharactersChangedDelta(delta, (index) => this.getAtomCharacterAt(index), callback));
             }
             getUniformRun(startIndex, endIndex) {
                 return this.content.getUniformRun(startIndex, endIndex);
@@ -216,24 +245,6 @@ export var FormattedText;
                 return this.content.getString(startIndex, endIndex);
             }
         }
-        _TextNode_instances = new WeakSet(), _TextNode_fullString_reference = function _TextNode_fullString_reference() {
-            return [...this.characters()].join("");
-        }, _TextNode_charactersCopy_reference = function _TextNode_charactersCopy_reference() {
-            return [...this.characters()];
-        }, _TextNode_editRange = function _TextNode_editRange(start, end, method, edit) {
-            const formatStart = start ?? 0;
-            validateIndex(formatStart, this.content, method, true);
-            const formatEnd = Math.min(this.content.length, end ?? this.content.length);
-            validateIndexRange(formatStart, formatEnd, this.content, method);
-            TreeAlpha.context(this).runTransaction(() => {
-                for (let i = formatStart; i < formatEnd; i++) {
-                    const atom = this.content[i];
-                    // Range validated above, so this should never fail.
-                    assert(atom !== undefined, 0xd08 /* Index out of bounds while formatting text range. */);
-                    edit(atom);
-                }
-            });
-        };
         function stringTextAtomsFromString(value) {
             // TypeScript can't prove in this Generic context that StringTextAtom is assignable to TextAtomNode, so we have to cast.
             // Since TextAtomSchemas unconditionally includes StringTextAtom, this cast is safe.