@fluidframework/tree 2.101.1 → 2.103.0

package/dist/simple-tree/simpleSchemaFormatV1.js

@@ -3,6 +3,29 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleTreeSchemaFormat = exports.SimpleSchemaDefinitionsFormat = exports.SimpleNodeSchemaUnionFormat = exports.SimpleObjectNodeSchemaFormat = exports.SimpleObjectFieldSchemasFormat = exports.SimpleLeafNodeSchemaFormat = exports.SimpleRecordNodeSchemaFormat = exports.SimpleMapNodeSchemaFormat = exports.SimpleArrayNodeSchemaFormat = exports.SimpleObjectFieldSchemaFormat = exports.SimpleFieldSchemaFormat = exports.SimpleAllowedTypesFormat = exports.SimpleAllowedTypeAttributesFormat = exports.SimpleSchemaFormatVersion = void 0;
 /*
@@ -12,7 +35,7 @@ exports.SimpleTreeSchemaFormat = exports.SimpleSchemaDefinitionsFormat = exports
  * This only includes all parts of the schema that impact compatibility according to SchemaCompatibilityTester.
  * It may not include some details which impact maintenance of application enforced invariants (like persisted metadata or logic in view schema).
  */
-const typebox_1 = require("@sinclair/typebox");
+const Type = __importStar(require("@sinclair/typebox"));
 const noAdditionalProps = { additionalProperties: false };
 /**
  * The format version for the schema.
@@ -24,98 +47,98 @@ exports.SimpleSchemaFormatVersion = {
  * The allowed types and their attributes in the simple schema format.
  * @see {@link SimpleAllowedTypes}.
  */
-exports.SimpleAllowedTypeAttributesFormat = typebox_1.Type.Object({
-    isStaged: typebox_1.Type.Optional(typebox_1.Type.Boolean()),
+exports.SimpleAllowedTypeAttributesFormat = Type.Object({
+    isStaged: Type.Optional(Type.Boolean()),
 }, noAdditionalProps);
 /**
  * A set of allowed types in the simple schema format.
  * The keys are the type identifiers, and the values are their attributes.
  */
-exports.SimpleAllowedTypesFormat = typebox_1.Type.Record(typebox_1.Type.String(), exports.SimpleAllowedTypeAttributesFormat);
+exports.SimpleAllowedTypesFormat = Type.Record(Type.String(), exports.SimpleAllowedTypeAttributesFormat);
 /**
  * Persisted format for a field schema in the simple schema format.
  * @see {@link SimpleFieldSchema}.
  */
-exports.SimpleFieldSchemaFormat = typebox_1.Type.Object({
-    kind: typebox_1.Type.Integer(),
+exports.SimpleFieldSchemaFormat = Type.Object({
+    kind: Type.Integer(),
     simpleAllowedTypes: exports.SimpleAllowedTypesFormat,
 }, noAdditionalProps);
 /**
  * Persisted format for an object field schema in the simple schema format.
  * @see {@link SimpleObjectFieldSchema}.
  */
-exports.SimpleObjectFieldSchemaFormat = typebox_1.Type.Object({
-    kind: typebox_1.Type.Integer(),
+exports.SimpleObjectFieldSchemaFormat = Type.Object({
+    kind: Type.Integer(),
     simpleAllowedTypes: exports.SimpleAllowedTypesFormat,
-    storedKey: typebox_1.Type.String(),
+    storedKey: Type.String(),
 }, noAdditionalProps);
 /**
  * Persisted format for an array node schema in the simple schema format.
  * @see {@link SimpleArrayNodeSchema}.
  */
-exports.SimpleArrayNodeSchemaFormat = typebox_1.Type.Object({
-    kind: typebox_1.Type.Integer(),
+exports.SimpleArrayNodeSchemaFormat = Type.Object({
+    kind: Type.Integer(),
     simpleAllowedTypes: exports.SimpleAllowedTypesFormat,
 }, noAdditionalProps);
 /**
  * Persisted format for a map node schema in the simple schema format.
  * @see {@link SimpleMapNodeSchema}.
  */
-exports.SimpleMapNodeSchemaFormat = typebox_1.Type.Object({
-    kind: typebox_1.Type.Integer(),
+exports.SimpleMapNodeSchemaFormat = Type.Object({
+    kind: Type.Integer(),
     simpleAllowedTypes: exports.SimpleAllowedTypesFormat,
 }, noAdditionalProps);
 /**
  * Persisted format for a record node schema in the simple schema format.
  * @see {@link SimpleRecordNodeSchema}.
  */
-exports.SimpleRecordNodeSchemaFormat = typebox_1.Type.Object({
-    kind: typebox_1.Type.Integer(),
+exports.SimpleRecordNodeSchemaFormat = Type.Object({
+    kind: Type.Integer(),
     simpleAllowedTypes: exports.SimpleAllowedTypesFormat,
 }, noAdditionalProps);
 /**
  * Persisted format for a leaf node schema in the simple schema format.
  * @see {@link SimpleLeafNodeSchema}.
  */
-exports.SimpleLeafNodeSchemaFormat = typebox_1.Type.Object({
-    kind: typebox_1.Type.Integer(),
-    leafKind: typebox_1.Type.Integer(),
+exports.SimpleLeafNodeSchemaFormat = Type.Object({
+    kind: Type.Integer(),
+    leafKind: Type.Integer(),
 }, noAdditionalProps);
 /**
  * Persisted format for the field schemas of an object node in the simple schema format.
  */
-exports.SimpleObjectFieldSchemasFormat = typebox_1.Type.Record(typebox_1.Type.String(), exports.SimpleObjectFieldSchemaFormat);
+exports.SimpleObjectFieldSchemasFormat = Type.Record(Type.String(), exports.SimpleObjectFieldSchemaFormat);
 /**
  * Persisted format for an object node schema in the simple schema format.
  * @see {@link SimpleObjectNodeSchema}.
  */
-exports.SimpleObjectNodeSchemaFormat = typebox_1.Type.Object({
-    kind: typebox_1.Type.Integer(),
+exports.SimpleObjectNodeSchemaFormat = Type.Object({
+    kind: Type.Integer(),
     fields: exports.SimpleObjectFieldSchemasFormat,
-    allowUnknownOptionalFields: typebox_1.Type.Optional(typebox_1.Type.Boolean()),
+    allowUnknownOptionalFields: Type.Optional(Type.Boolean()),
 }, noAdditionalProps);
 /**
  * Discriminated union of all possible node schemas.
  *
  * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.
  */
-exports.SimpleNodeSchemaUnionFormat = typebox_1.Type.Object({
-    array: typebox_1.Type.Optional(exports.SimpleArrayNodeSchemaFormat),
-    map: typebox_1.Type.Optional(exports.SimpleMapNodeSchemaFormat),
-    record: typebox_1.Type.Optional(exports.SimpleRecordNodeSchemaFormat),
-    leaf: typebox_1.Type.Optional(exports.SimpleLeafNodeSchemaFormat),
-    object: typebox_1.Type.Optional(exports.SimpleObjectNodeSchemaFormat),
+exports.SimpleNodeSchemaUnionFormat = Type.Object({
+    array: Type.Optional(exports.SimpleArrayNodeSchemaFormat),
+    map: Type.Optional(exports.SimpleMapNodeSchemaFormat),
+    record: Type.Optional(exports.SimpleRecordNodeSchemaFormat),
+    leaf: Type.Optional(exports.SimpleLeafNodeSchemaFormat),
+    object: Type.Optional(exports.SimpleObjectNodeSchemaFormat),
 });
 /**
  * Helper type for the schema definitions map in the persisted format.
  */
-exports.SimpleSchemaDefinitionsFormat = typebox_1.Type.Record(typebox_1.Type.String(), exports.SimpleNodeSchemaUnionFormat);
+exports.SimpleSchemaDefinitionsFormat = Type.Record(Type.String(), exports.SimpleNodeSchemaUnionFormat);
 /**
  * Persisted format for the compatibility impacting subset of simple schema.
  * @see {@link SimpleTreeSchema}.
  */
-exports.SimpleTreeSchemaFormat = typebox_1.Type.Object({
-    version: typebox_1.Type.Literal(exports.SimpleSchemaFormatVersion.v1),
+exports.SimpleTreeSchemaFormat = Type.Object({
+    version: Type.Literal(exports.SimpleSchemaFormatVersion.v1),
     root: exports.SimpleFieldSchemaFormat,
     definitions: exports.SimpleSchemaDefinitionsFormat,
 }, noAdditionalProps);

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

@@ -1 +1 @@
-{"version":3,"file":"simpleSchemaFormatV1.js","sourceRoot":"","sources":["../../src/simple-tree/simpleSchemaFormatV1.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\n/*\n * This file contains a format for serializing the compatibility impacting subset of simple schema.\n\n * This format can be used for both view and stored simple schema.\n * This only includes all parts of the schema that impact compatibility according to SchemaCompatibilityTester.\n * It may not include some details which impact maintenance of application enforced invariants (like persisted metadata or logic in view schema).\n */\n\nimport { Type, type ObjectOptions, type Static } from \"@sinclair/typebox\";\n\nconst noAdditionalProps: ObjectOptions = { additionalProperties: false };\n\n/**\n * The format version for the schema.\n */\nexport const SimpleSchemaFormatVersion = {\n\tv1: 1,\n} as const;\n\n/**\n * The allowed types and their attributes in the simple schema format.\n * @see {@link SimpleAllowedTypes}.\n */\nexport const SimpleAllowedTypeAttributesFormat = Type.Object(\n\t{\n\t\tisStaged: Type.Optional(Type.Boolean()),\n\t},\n\tnoAdditionalProps,\n);\n\nexport type SimpleAllowedTypeAttributesFormat = Static<\n\ttypeof SimpleAllowedTypeAttributesFormat\n>;\n\n/**\n * A set of allowed types in the simple schema format.\n * The keys are the type identifiers, and the values are their attributes.\n */\nexport const SimpleAllowedTypesFormat = Type.Record(\n\tType.String(),\n\tSimpleAllowedTypeAttributesFormat,\n);\nexport type SimpleAllowedTypesFormat = Static<typeof SimpleAllowedTypesFormat>;\n\n/**\n * Persisted format for a field schema in the simple schema format.\n * @see {@link SimpleFieldSchema}.\n */\nexport const SimpleFieldSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleFieldSchemaFormat = Static<typeof SimpleFieldSchemaFormat>;\n\n/**\n * Persisted format for an object field schema in the simple schema format.\n * @see {@link SimpleObjectFieldSchema}.\n */\nexport const SimpleObjectFieldSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t\tstoredKey: Type.String(),\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleObjectFieldSchemaFormat = Static<typeof SimpleObjectFieldSchemaFormat>;\n\n/**\n * Persisted format for an array node schema in the simple schema format.\n * @see {@link SimpleArrayNodeSchema}.\n */\nexport const SimpleArrayNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleArrayNodeSchemaFormat = Static<typeof SimpleArrayNodeSchemaFormat>;\n\n/**\n * Persisted format for a map node schema in the simple schema format.\n * @see {@link SimpleMapNodeSchema}.\n */\nexport const SimpleMapNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleMapNodeSchemaFormat = Static<typeof SimpleMapNodeSchemaFormat>;\n\n/**\n * Persisted format for a record node schema in the simple schema format.\n * @see {@link SimpleRecordNodeSchema}.\n */\nexport const SimpleRecordNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleRecordNodeSchemaFormat = Static<typeof SimpleRecordNodeSchemaFormat>;\n\n/**\n * Persisted format for a leaf node schema in the simple schema format.\n * @see {@link SimpleLeafNodeSchema}.\n */\nexport const SimpleLeafNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tleafKind: Type.Integer(),\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleLeafNodeSchemaFormat = Static<typeof SimpleLeafNodeSchemaFormat>;\n\n/**\n * Persisted format for the field schemas of an object node in the simple schema format.\n */\nexport const SimpleObjectFieldSchemasFormat = Type.Record(\n\tType.String(),\n\tSimpleObjectFieldSchemaFormat,\n);\nexport type SimpleObjectFieldSchemasFormat = Static<typeof SimpleObjectFieldSchemasFormat>;\n\n/**\n * Persisted format for an object node schema in the simple schema format.\n * @see {@link SimpleObjectNodeSchema}.\n */\nexport const SimpleObjectNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tfields: SimpleObjectFieldSchemasFormat,\n\t\tallowUnknownOptionalFields: Type.Optional(Type.Boolean()),\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleObjectNodeSchemaFormat = Static<typeof SimpleObjectNodeSchemaFormat>;\n\n/**\n * Discriminated union of all possible node schemas.\n *\n * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.\n */\nexport const SimpleNodeSchemaUnionFormat = Type.Object({\n\tarray: Type.Optional(SimpleArrayNodeSchemaFormat),\n\tmap: Type.Optional(SimpleMapNodeSchemaFormat),\n\trecord: Type.Optional(SimpleRecordNodeSchemaFormat),\n\tleaf: Type.Optional(SimpleLeafNodeSchemaFormat),\n\tobject: Type.Optional(SimpleObjectNodeSchemaFormat),\n});\nexport type SimpleNodeSchemaUnionFormat = Static<typeof SimpleNodeSchemaUnionFormat>;\n\n/**\n * Helper type for the schema definitions map in the persisted format.\n */\nexport const SimpleSchemaDefinitionsFormat = Type.Record(\n\tType.String(),\n\tSimpleNodeSchemaUnionFormat,\n);\nexport type SimpleSchemaDefinitionsFormat = Static<typeof SimpleSchemaDefinitionsFormat>;\n\n/**\n * Persisted format for the compatibility impacting subset of simple schema.\n * @see {@link SimpleTreeSchema}.\n */\nexport const SimpleTreeSchemaFormat = Type.Object(\n\t{\n\t\tversion: Type.Literal(SimpleSchemaFormatVersion.v1),\n\t\troot: SimpleFieldSchemaFormat,\n\t\tdefinitions: SimpleSchemaDefinitionsFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleTreeSchemaFormat = Static<typeof SimpleTreeSchemaFormat>;\n"]}
+{"version":3,"file":"simpleSchemaFormatV1.js","sourceRoot":"","sources":["../../src/simple-tree/simpleSchemaFormatV1.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\n/*\n * This file contains a format for serializing the compatibility impacting subset of simple schema.\n\n * This format can be used for both view and stored simple schema.\n * This only includes all parts of the schema that impact compatibility according to SchemaCompatibilityTester.\n * It may not include some details which impact maintenance of application enforced invariants (like persisted metadata or logic in view schema).\n */\n\nimport * as Type from \"@sinclair/typebox\";\nimport type { ObjectOptions, Static } from \"@sinclair/typebox\";\n\nconst noAdditionalProps: ObjectOptions = { additionalProperties: false };\n\n/**\n * The format version for the schema.\n */\nexport const SimpleSchemaFormatVersion = {\n\tv1: 1,\n} as const;\n\n/**\n * The allowed types and their attributes in the simple schema format.\n * @see {@link SimpleAllowedTypes}.\n */\nexport const SimpleAllowedTypeAttributesFormat = Type.Object(\n\t{\n\t\tisStaged: Type.Optional(Type.Boolean()),\n\t},\n\tnoAdditionalProps,\n);\n\nexport type SimpleAllowedTypeAttributesFormat = Static<\n\ttypeof SimpleAllowedTypeAttributesFormat\n>;\n\n/**\n * A set of allowed types in the simple schema format.\n * The keys are the type identifiers, and the values are their attributes.\n */\nexport const SimpleAllowedTypesFormat = Type.Record(\n\tType.String(),\n\tSimpleAllowedTypeAttributesFormat,\n);\nexport type SimpleAllowedTypesFormat = Static<typeof SimpleAllowedTypesFormat>;\n\n/**\n * Persisted format for a field schema in the simple schema format.\n * @see {@link SimpleFieldSchema}.\n */\nexport const SimpleFieldSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleFieldSchemaFormat = Static<typeof SimpleFieldSchemaFormat>;\n\n/**\n * Persisted format for an object field schema in the simple schema format.\n * @see {@link SimpleObjectFieldSchema}.\n */\nexport const SimpleObjectFieldSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t\tstoredKey: Type.String(),\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleObjectFieldSchemaFormat = Static<typeof SimpleObjectFieldSchemaFormat>;\n\n/**\n * Persisted format for an array node schema in the simple schema format.\n * @see {@link SimpleArrayNodeSchema}.\n */\nexport const SimpleArrayNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleArrayNodeSchemaFormat = Static<typeof SimpleArrayNodeSchemaFormat>;\n\n/**\n * Persisted format for a map node schema in the simple schema format.\n * @see {@link SimpleMapNodeSchema}.\n */\nexport const SimpleMapNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleMapNodeSchemaFormat = Static<typeof SimpleMapNodeSchemaFormat>;\n\n/**\n * Persisted format for a record node schema in the simple schema format.\n * @see {@link SimpleRecordNodeSchema}.\n */\nexport const SimpleRecordNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tsimpleAllowedTypes: SimpleAllowedTypesFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleRecordNodeSchemaFormat = Static<typeof SimpleRecordNodeSchemaFormat>;\n\n/**\n * Persisted format for a leaf node schema in the simple schema format.\n * @see {@link SimpleLeafNodeSchema}.\n */\nexport const SimpleLeafNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tleafKind: Type.Integer(),\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleLeafNodeSchemaFormat = Static<typeof SimpleLeafNodeSchemaFormat>;\n\n/**\n * Persisted format for the field schemas of an object node in the simple schema format.\n */\nexport const SimpleObjectFieldSchemasFormat = Type.Record(\n\tType.String(),\n\tSimpleObjectFieldSchemaFormat,\n);\nexport type SimpleObjectFieldSchemasFormat = Static<typeof SimpleObjectFieldSchemasFormat>;\n\n/**\n * Persisted format for an object node schema in the simple schema format.\n * @see {@link SimpleObjectNodeSchema}.\n */\nexport const SimpleObjectNodeSchemaFormat = Type.Object(\n\t{\n\t\tkind: Type.Integer(),\n\t\tfields: SimpleObjectFieldSchemasFormat,\n\t\tallowUnknownOptionalFields: Type.Optional(Type.Boolean()),\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleObjectNodeSchemaFormat = Static<typeof SimpleObjectNodeSchemaFormat>;\n\n/**\n * Discriminated union of all possible node schemas.\n *\n * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.\n */\nexport const SimpleNodeSchemaUnionFormat = Type.Object({\n\tarray: Type.Optional(SimpleArrayNodeSchemaFormat),\n\tmap: Type.Optional(SimpleMapNodeSchemaFormat),\n\trecord: Type.Optional(SimpleRecordNodeSchemaFormat),\n\tleaf: Type.Optional(SimpleLeafNodeSchemaFormat),\n\tobject: Type.Optional(SimpleObjectNodeSchemaFormat),\n});\nexport type SimpleNodeSchemaUnionFormat = Static<typeof SimpleNodeSchemaUnionFormat>;\n\n/**\n * Helper type for the schema definitions map in the persisted format.\n */\nexport const SimpleSchemaDefinitionsFormat = Type.Record(\n\tType.String(),\n\tSimpleNodeSchemaUnionFormat,\n);\nexport type SimpleSchemaDefinitionsFormat = Static<typeof SimpleSchemaDefinitionsFormat>;\n\n/**\n * Persisted format for the compatibility impacting subset of simple schema.\n * @see {@link SimpleTreeSchema}.\n */\nexport const SimpleTreeSchemaFormat = Type.Object(\n\t{\n\t\tversion: Type.Literal(SimpleSchemaFormatVersion.v1),\n\t\troot: SimpleFieldSchemaFormat,\n\t\tdefinitions: SimpleSchemaDefinitionsFormat,\n\t},\n\tnoAdditionalProps,\n);\nexport type SimpleTreeSchemaFormat = Static<typeof SimpleTreeSchemaFormat>;\n"]}

package/dist/text/codePointUtils.d.ts

@@ -0,0 +1,48 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Returns the number of Unicode code points in `value`.
+ * @remarks
+ * Use this to translate a JavaScript string length (which is in UTF-16 code units) into
+ * the atom/code-point space used by {@link TextAsTree}.
+ *
+ * @example
+ * ```typescript
+ * codePointCount("");     // 0
+ * codePointCount("abc");  // 3
+ * codePointCount("a😀b"); // 3 — emoji is one code point, but "a😀b".length === 4 (UTF-16 surrogate pair)
+ * ```
+ *
+ * @internal
+ */
+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 TextAsTree}-space counts (code points) into JavaScript string indices (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
+ * would misalign delta offsets applied to strings rather than surface the drift to the caller.
+ *
+ * @example
+ * ```typescript
+ * utf16LengthForCodePoints("abc", 0, 3);  // 3 — three single-unit characters
+ * utf16LengthForCodePoints("a😀b", 0, 3); // 4 — a (1) + 😀 (2) + b (1)
+ * utf16LengthForCodePoints("a😀b", 1, 1); // 2 — just the emoji
+ * utf16LengthForCodePoints("abc", 0, 0);  // 0 — no code points requested
+ * ```
+ *
+ * @param value - The string to measure.
+ * @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`.
+ * @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
+ */
+export declare function utf16LengthForCodePoints(value: string, start: number, count: number): number;
+//# sourceMappingURL=codePointUtils.d.ts.map

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

@@ -0,0 +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"}

package/dist/text/codePointUtils.js

@@ -0,0 +1,80 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf16LengthForCodePoints = exports.codePointCount = void 0;
+const internal_1 = require("@fluidframework/telemetry-utils/internal");
+/**
+ * Returns the number of Unicode code points in `value`.
+ * @remarks
+ * Use this to translate a JavaScript string length (which is in UTF-16 code units) into
+ * the atom/code-point space used by {@link TextAsTree}.
+ *
+ * @example
+ * ```typescript
+ * codePointCount("");     // 0
+ * codePointCount("abc");  // 3
+ * codePointCount("a😀b"); // 3 — emoji is one code point, but "a😀b".length === 4 (UTF-16 surrogate pair)
+ * ```
+ *
+ * @internal
+ */
+function codePointCount(value) {
+    // Iterate instead of spreading to avoid allocating an intermediate array.
+    let count = 0;
+    for (const _ of value) {
+        count++;
+    }
+    return count;
+}
+exports.codePointCount = codePointCount;
+/**
+ * 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 TextAsTree}-space counts (code points) into JavaScript string indices (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
+ * would misalign delta offsets applied to strings rather than surface the drift to the caller.
+ *
+ * @example
+ * ```typescript
+ * utf16LengthForCodePoints("abc", 0, 3);  // 3 — three single-unit characters
+ * utf16LengthForCodePoints("a😀b", 0, 3); // 4 — a (1) + 😀 (2) + b (1)
+ * utf16LengthForCodePoints("a😀b", 1, 1); // 2 — just the emoji
+ * utf16LengthForCodePoints("abc", 0, 0);  // 0 — no code points requested
+ * ```
+ *
+ * @param value - The string to measure.
+ * @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`.
+ * @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
+ */
+function utf16LengthForCodePoints(value, start, count) {
+    if (start < 0 || start > value.length) {
+        throw new internal_1.UsageError(`start (${start}) must be within [0, ${value.length}] (value.length).`);
+    }
+    if (count < 0) {
+        throw new internal_1.UsageError(`count (${count}) must be non-negative.`);
+    }
+    let utf16 = 0;
+    let counted = 0;
+    while (counted < count && start + utf16 < 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 internal_1.UsageError(`count (${count}) exceeds the ${counted} code point(s) available from start (${start}) in a value of length ${value.length}.`);
+    }
+    return utf16;
+}
+exports.utf16LengthForCodePoints = utf16LengthForCodePoints;
+//# sourceMappingURL=codePointUtils.js.map

package/dist/text/codePointUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codePointUtils.js","sourceRoot":"","sources":["../../src/text/codePointUtils.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,uEAAsE;AAEtE;;;;;;;;;;;;;;GAcG;AACH,SAAgB,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;AAPD,wCAOC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAAgB,wBAAwB,CAAC,KAAa,EAAE,KAAa,EAAE,KAAa;IACnF,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;QACvC,MAAM,IAAI,qBAAU,CACnB,UAAU,KAAK,wBAAwB,KAAK,CAAC,MAAM,mBAAmB,CACtE,CAAC;IACH,CAAC;IACD,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACf,MAAM,IAAI,qBAAU,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,qBAAU,CACnB,UAAU,KAAK,iBAAiB,OAAO,wCAAwC,KAAK,0BAA0B,KAAK,CAAC,MAAM,GAAG,CAC7H,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC;AAvBD,4DAuBC","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 TextAsTree}.\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 TextAsTree}-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"]}

package/dist/text/index.d.ts

@@ -4,4 +4,5 @@
  */
 export { TextAsTree } from "./textDomain.js";
 export { FormattedTextAsTree } from "./textDomainFormatted.js";
+export { codePointCount, utf16LengthForCodePoints } from "./codePointUtils.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/text/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/text/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/text/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/text/index.js

@@ -4,9 +4,12 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FormattedTextAsTree = exports.TextAsTree = void 0;
+exports.utf16LengthForCodePoints = exports.codePointCount = exports.FormattedTextAsTree = exports.TextAsTree = void 0;
 var textDomain_js_1 = require("./textDomain.js");
 Object.defineProperty(exports, "TextAsTree", { enumerable: true, get: function () { return textDomain_js_1.TextAsTree; } });
 var textDomainFormatted_js_1 = require("./textDomainFormatted.js");
 Object.defineProperty(exports, "FormattedTextAsTree", { enumerable: true, get: function () { return textDomainFormatted_js_1.FormattedTextAsTree; } });
+var codePointUtils_js_1 = require("./codePointUtils.js");
+Object.defineProperty(exports, "codePointCount", { enumerable: true, get: function () { return codePointUtils_js_1.codePointCount; } });
+Object.defineProperty(exports, "utf16LengthForCodePoints", { enumerable: true, get: function () { return codePointUtils_js_1.utf16LengthForCodePoints; } });
 //# sourceMappingURL=index.js.map

package/dist/text/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/text/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,iDAA6C;AAApC,2GAAA,UAAU,OAAA;AACnB,mEAA+D;AAAtD,6HAAA,mBAAmB,OAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport { TextAsTree } from \"./textDomain.js\";\nexport { FormattedTextAsTree } from \"./textDomainFormatted.js\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/text/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,iDAA6C;AAApC,2GAAA,UAAU,OAAA;AACnB,mEAA+D;AAAtD,6HAAA,mBAAmB,OAAA;AAC5B,yDAA+E;AAAtE,mHAAA,cAAc,OAAA;AAAE,6HAAA,wBAAwB,OAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport { TextAsTree } from \"./textDomain.js\";\nexport { FormattedTextAsTree } from \"./textDomainFormatted.js\";\nexport { codePointCount, utf16LengthForCodePoints } from \"./codePointUtils.js\";\n"]}

package/dist/text/textDomain.d.ts

@@ -2,7 +2,7 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import type { TreeNode, WithType } from "../simple-tree/index.js";
+import type { ArrayNodeDeltaOp, ArrayNodeTreeChangedDeltaOp, TreeNode, WithType } from "../simple-tree/index.js";
 import type { NodeKind, TreeNodeSchema } from "../simple-tree/index.js";
 /**
  * Interpret a string as an iterable of characters.
@@ -12,6 +12,21 @@ import type { NodeKind, TreeNodeSchema } from "../simple-tree/index.js";
  * Additionally using this function consistently will make any refactors to support alternative character boundaries easier.
  */
 export declare function charactersFromString(value: string): Iterable<string>;
+/**
+ * Processes an array-node delta into a {@link TextAsTree.TextOp}[] and calls `callback`.
+ * @remarks
+ * Shared by both the plain `onCharactersChanged` (from `nodeChanged`) and formatted `onContentChanged`
+ * (from `treeChanged`) implementations.
+ * @param delta - The raw array-node delta, or `undefined` when no delta is available.
+ * When retain ops carry `subtreeChanged` (i.e. delta comes from a `treeChanged` event), the emitted
+ * retain ops include an explicit `formattingChanged: boolean`. Otherwise `formattingChanged` is omitted.
+ * @param getCharacter - Returns the character string at the given array index in the **post-edit** tree.
+ * Only invoked for insert ops, where it must read the inserted character at the given index of the tree
+ * after the edit has been applied. Passing an accessor that reads pre-edit content will silently produce wrong text.
+ * Return `undefined` if the tree is out of sync with the delta; this triggers a full-reread fallback.
+ * @param callback - The user-supplied callback to invoke with the translated ops.
+ */
+export declare function processCharactersChangedDelta(delta: readonly (ArrayNodeDeltaOp | ArrayNodeTreeChangedDeltaOp)[] | undefined, getCharacter: (index: number) => string | undefined, callback: (ops: readonly TextAsTree.TextOp[] | undefined) => void): void;
 /**
  * A collection of text related types, schema and utilities for working with text beyond the basic {@link SchemaStatics.string}.
  * @privateRemarks
@@ -75,6 +90,67 @@ export declare function charactersFromString(value: string): Iterable<string>;
  * @alpha
  */
 export declare namespace TextAsTree {
+    /**
+     * A retain op in a character-level delta — a span of unchanged characters that the consumer should skip over.
+     * @sealed
+     * @alpha
+     */
+    interface TextRetainOp {
+        /**
+         * Discriminator identifying this op as a retain.
+         */
+        readonly type: "retain";
+        /**
+         * The number of Unicode code points to retain.
+         */
+        readonly count: number;
+        /**
+         * Whether at least one character in the retained range had a deep change.
+         * @remarks
+         * Present only on retain ops delivered by {@link @fluidframework/tree#FormattedTextAsTree.Members.onContentChanged};
+         * always absent on retain ops delivered by {@link TextAsTree.Members.onCharactersChanged}.
+         * When present, `true` indicates the retained range contained a formatting property update
+         * or an atom content edit; `false` indicates no deep change.
+         */
+        readonly formattingChanged?: boolean;
+    }
+    /**
+     * An insert op in a character-level delta — characters newly added to the text.
+     * @remarks
+     * Carries the inserted text as a single string, which is more convenient for consumers than individual characters.
+     * @sealed
+     * @alpha
+     */
+    interface TextInsertOp {
+        /**
+         * Discriminator identifying this op as an insert.
+         */
+        readonly type: "insert";
+        /**
+         * The newly inserted characters, concatenated into a single string.
+         */
+        readonly text: string;
+    }
+    /**
+     * A remove op in a character-level delta — a span of characters that has been deleted from the text.
+     * @sealed
+     * @alpha
+     */
+    interface TextRemoveOp {
+        /**
+         * Discriminator identifying this op as a remove.
+         */
+        readonly type: "remove";
+        /**
+         * The number of Unicode code points removed.
+         */
+        readonly count: number;
+    }
+    /**
+     * A single operation in a character-level delta describing an insert, remove, or retain of text.
+     * @alpha
+     */
+    type TextOp = TextRetainOp | TextInsertOp | TextRemoveOp;
     /**
      * Statics for text nodes.
      * @alpha
@@ -101,6 +177,7 @@ export declare namespace TextAsTree {
      *
      * @see {@link TextAsTree.Statics.fromString} for construction.
      * @see {@link TextAsTree.(Tree:type)} for schema.
+     * @sealed
      * @alpha
      */
     interface Members {
@@ -145,6 +222,21 @@ export declare namespace TextAsTree {
          * See {@link (TreeArrayNode:interface).removeRange} for more details on the behavior.
          */
         removeRange(startIndex: number | undefined, endIndex: number | undefined): void;
+        /**
+         * Subscribe to shallow character-level changes on this text node — inserts and removes only.
+         * @param callback - Called after each change with a sequence of {@link TextAsTree.TextOp}s describing what changed,
+         * or `undefined` when a delta could not be computed (e.g. during a schema upgrade).
+         * @returns A cleanup function that unsubscribes the callback when called.
+         * @remarks
+         * Only fires on shallow changes — inserts and removes.
+         * It does not fire on deep changes such as formatting property updates on existing characters.
+         * For formatted text, use {@link @fluidframework/tree#FormattedTextAsTree.Members.onContentChanged} to also receive deep changes.
+         *
+         * All counts in the delivered ops are in Unicode code points, not UTF-16 code units.
+         * For characters outside the Basic Multilingual Plane (e.g. emoji), one code point
+         * corresponds to two UTF-16 code units — convert before using the counts as string indices.
+         */
+        onCharactersChanged(callback: (ops: readonly TextOp[] | undefined) => void): () => void;
     }
     /**
      * Schema for a {@link TextAsTree.(Tree:variable)} node.

package/dist/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,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAIlE,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AA8HxE;;;;;;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"}
+{"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;AAsIxE;;;;;;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,UAAU,CAAC,MAAM,EAAE,GAAG,SAAS,KAAK,IAAI,GAC/D,IAAI,CAqCN;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,yBAAiB,UAAU,CAAC;IAC3B;;;;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"}

package/dist/text/textDomain.js

@@ -4,15 +4,16 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TextAsTree = exports.charactersFromString = void 0;
+exports.TextAsTree = exports.processCharactersChangedDelta = exports.charactersFromString = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const alpha_1 = require("@fluidframework/type-factory/alpha");
 const internal_2 = require("@fluidframework/type-factory/internal");
 const index_js_1 = require("../core/index.js");
-const index_js_2 = require("../simple-tree/index.js");
-const sf = new index_js_2.SchemaFactoryAlpha("com.fluidframework.text");
+const index_js_2 = require("../shared-tree/index.js");
+const index_js_3 = require("../simple-tree/index.js");
+const sf = new index_js_3.SchemaFactoryAlpha("com.fluidframework.text");
 class TextNode extends sf.object("Text", {
-    content: index_js_2.SchemaFactory.required([() => StringArray], { key: index_js_1.EmptyKey }),
+    content: index_js_3.SchemaFactory.required([() => StringArray], { key: index_js_1.EmptyKey }),
 }) {
     static [alpha_1.exposeMethodsSymbol](methods) {
         methods.exposeMethod(TextNode, "insertAt", (0, alpha_1.buildFunc)({
@@ -40,7 +41,7 @@ class TextNode extends sf.object("Text", {
         TextNode[alpha_1.exposeMethodsSymbol](methods);
     }
     insertAt(index, additionalCharacters) {
-        this.content.insertAt(index, index_js_2.TreeArrayNode.spread(charactersFromString(additionalCharacters)));
+        this.content.insertAt(index, index_js_3.TreeArrayNode.spread(charactersFromString(additionalCharacters)));
     }
     removeRange(index, end) {
         this.content.removeRange(index, end);
@@ -74,6 +75,9 @@ class TextNode extends sf.object("Text", {
     charactersCopy_reference() {
         return [...this.content];
     }
+    onCharactersChanged(callback) {
+        return index_js_2.TreeAlpha.on(this.content, "nodeChanged", ({ delta }) => processCharactersChangedDelta(delta, (i) => this.content[i], callback));
+    }
     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.
@@ -95,9 +99,9 @@ function charactersFromString(value) {
     return value;
 }
 exports.charactersFromString = charactersFromString;
-class StringArray extends sf.array("StringArray", index_js_2.SchemaFactory.string) {
+class StringArray extends sf.array("StringArray", index_js_3.SchemaFactory.string) {
     withBorrowedSequenceCursor(f) {
-        const cursor = (0, index_js_2.getInnerNode)(this).borrowCursor();
+        const cursor = (0, index_js_3.getInnerNode)(this).borrowCursor();
         cursor.enterField(index_js_1.EmptyKey);
         const result = f(cursor);
         cursor.exitField();
@@ -110,6 +114,59 @@ class StringArray extends sf.array("StringArray", index_js_2.SchemaFactory.strin
         return this.charactersCopy().join("");
     }
 }
+/**
+ * Processes an array-node delta into a {@link TextAsTree.TextOp}[] and calls `callback`.
+ * @remarks
+ * Shared by both the plain `onCharactersChanged` (from `nodeChanged`) and formatted `onContentChanged`
+ * (from `treeChanged`) implementations.
+ * @param delta - The raw array-node delta, or `undefined` when no delta is available.
+ * When retain ops carry `subtreeChanged` (i.e. delta comes from a `treeChanged` event), the emitted
+ * retain ops include an explicit `formattingChanged: boolean`. Otherwise `formattingChanged` is omitted.
+ * @param getCharacter - Returns the character string at the given array index in the **post-edit** tree.
+ * Only invoked for insert ops, where it must read the inserted character at the given index of the tree
+ * after the edit has been applied. Passing an accessor that reads pre-edit content will silently produce wrong text.
+ * Return `undefined` if the tree is out of sync with the delta; this triggers a full-reread fallback.
+ * @param callback - The user-supplied callback to invoke with the translated ops.
+ */
+function processCharactersChangedDelta(delta, getCharacter, callback) {
+    if (delta === undefined) {
+        callback(undefined);
+        return;
+    }
+    let readPosition = 0;
+    const ops = [];
+    for (const op of delta) {
+        if (op.type === "retain") {
+            // `subtreeChanged` is only present on retain ops from `treeChanged` deltas.
+            ops.push("subtreeChanged" in op
+                ? { type: "retain", count: op.count, formattingChanged: op.subtreeChanged === true }
+                : { type: "retain", count: op.count });
+            readPosition += op.count;
+        }
+        else if (op.type === "insert") {
+            // Accumulate into an array and join at the end to keep this O(n) for large inserts
+            // (paste of long text) instead of O(n^2) from repeated string concatenation.
+            const characters = [];
+            for (let i = 0; i < op.count; i++) {
+                const character = getCharacter(readPosition);
+                if (character === undefined) {
+                    // Tree is out of sync with the delta — fall back to full re-read.
+                    callback(undefined);
+                    return;
+                }
+                characters.push(character);
+                readPosition++;
+            }
+            ops.push({ type: "insert", text: characters.join("") });
+        }
+        else {
+            // Construct explicit remove op so internal fields on the source op don't leak.
+            ops.push({ type: "remove", count: op.count });
+        }
+    }
+    callback(ops);
+}
+exports.processCharactersChangedDelta = processCharactersChangedDelta;
 /**
  * A collection of text related types, schema and utilities for working with text beyond the basic {@link SchemaStatics.string}.
  * @privateRemarks
@@ -180,6 +237,6 @@ var TextAsTree;
      * See {@link TextAsTree.Statics} for static APIs on this schema, including construction.
      * @alpha
      */
-    TextAsTree.Tree = (0, index_js_2.eraseSchemaDetails)()(TextNode);
+    TextAsTree.Tree = (0, index_js_3.eraseSchemaDetails)()(TextNode);
 })(TextAsTree || (exports.TextAsTree = TextAsTree = {}));
 //# sourceMappingURL=textDomain.js.map