@fluidframework/tree 2.113.1 → 2.114.0

package/lib/text/textDomainFormatted.d.ts

@@ -2,8 +2,46 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import type { TreeNodeSchema, LazyItem, ImplicitAllowedTypes, TreeFieldFromImplicitField, TreeNodeFromImplicitAllowedTypes, InsertableTreeNodeFromImplicitAllowedTypes, InsertableTreeFieldFromImplicitField, NodeKind, TreeNode, ScopedSchemaName, ErasedSchemaSubclassable, ErasedNode, SchemaFactoryBeta } from "../simple-tree/index.js";
+import type { TreeNodeSchema, LazyItem, ImplicitAllowedTypes, TreeNodeFromImplicitAllowedTypes, InsertableTreeNodeFromImplicitAllowedTypes, InsertableTreeFieldFromImplicitField, NodeKind, TreeNode, ScopedSchemaName, ErasedSchemaSubclassable, ErasedNode, SchemaFactoryBeta } from "../simple-tree/index.js";
 import { type TextAsTree } from "./textDomain.js";
+declare const StringTextAtomNode_base: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.StringTextAtom", NodeKind.Object, import("../simple-tree/index.js").TreeObjectNode<{
+    /**
+     * The underlying text content of this atom.
+     * @remarks
+     * This is typically a single Unicode code point, and thus may contain multiple UTF-16 surrogate pair code units.
+     * Longer strings are still valid. For example, users might store whole grapheme clusters here, or even longer sections of text.
+     * Anything combined into a single atom will be treated atomically, and can not be partially selected or formatted.
+     * Using larger atoms and splitting them as needed is NOT a recommended approach, since this will result in poor merge behavior for concurrent edits.
+     * Instead, atoms should always be the smallest unit of text which will be independently selected, moved or formatted.
+     * @privateRemarks
+     * This content logically represents the whole atom's content, so using {@link EmptyKey} makes sense to help indicate that.
+     */
+    readonly content: import("../simple-tree/fieldSchema.js").FieldSchema<import("../simple-tree/fieldSchema.js").FieldKind.Required, readonly [import("../simple-tree/leafNodeSchema.js").LeafSchema<"string", string>], unknown>;
+}, "com.fluidframework.text.formatted.StringTextAtom">, object & {
+    readonly content: string;
+}, true, {
+    /**
+     * The underlying text content of this atom.
+     * @remarks
+     * This is typically a single Unicode code point, and thus may contain multiple UTF-16 surrogate pair code units.
+     * Longer strings are still valid. For example, users might store whole grapheme clusters here, or even longer sections of text.
+     * Anything combined into a single atom will be treated atomically, and can not be partially selected or formatted.
+     * Using larger atoms and splitting them as needed is NOT a recommended approach, since this will result in poor merge behavior for concurrent edits.
+     * Instead, atoms should always be the smallest unit of text which will be independently selected, moved or formatted.
+     * @privateRemarks
+     * This content logically represents the whole atom's content, so using {@link EmptyKey} makes sense to help indicate that.
+     */
+    readonly content: import("../simple-tree/fieldSchema.js").FieldSchema<import("../simple-tree/fieldSchema.js").FieldKind.Required, readonly [import("../simple-tree/leafNodeSchema.js").LeafSchema<"string", string>], unknown>;
+}, never, unknown>;
+/**
+ * Atom in the string containing a single character.
+ * @privateRemarks
+ * This is outside the namespace so it can be exported for testing, but not package exported.
+ */
+export declare class StringTextAtomNode extends StringTextAtomNode_base implements FormattedTextAsTree.TextAtom {
+    static fromCharacter(value: string): StringTextAtomNode;
+    static fromString(value: string): StringTextAtomNode[];
+}
 /**
  * A collection of text related types, schema and utilities for working with text beyond the basic {@link SchemaStatics.string}.
  * @remarks
@@ -17,73 +55,102 @@ import { type TextAsTree } from "./textDomain.js";
  */
 export declare namespace FormattedTextAsTree {
     /**
-     * Factory for formatted text schema as a function of the formatting and the embedded object (atom) types.
+     * Creates a schema for a formatted text node, parameterized by the formatting and the embedded object (atom) types.
+     *
+     * @param inputSchemaFactory - The {@link SchemaFactoryBeta} used to scope the generated schema.
+     * The generated types are scoped under `com.fluidframework.text.formatted<TUserScope>`, where `TUserScope` is the scope of this factory.
+     * This scope is used to distinguish different usages of `createSchema` from each-other, and must be kept the same between versions for nodes to remain compatible.
+     * It must be different to distinguish different formatted text schema within the same document.
+     * @param formatSchema - Schema describing the formatting associated with each atom of text.
+     * Use an {@link NodeKind.Object|Object node} to support {@link FormattedTextAsTree.Members.formatRange}.
+     * @param extraAtoms - Additional atom schema to allow as text content beyond the built-in {@link FormattedTextAsTree.(StringTextAtom:variable)}.
+     * Use this to embed richer content (for example line breaks or inline objects) alongside plain characters.
+     * @param defaultFormatInsertable - The formatting applied to text inserted via non-formatted APIs
+     * (for example {@link FormattedTextAsTree.Members.insertAt} and {@link FormattedTextAsTree.Statics.fromString} when no explicit format is provided).
+     * @returns The schema for the formatted text node, whose nodes implement {@link FormattedTextAsTree.Members} and whose statics implement {@link FormattedTextAsTree.Statics}.
+     * @remarks
+     * See {@link FormattedTextAsTreeDefault} for a default parameterization of this factory.
+     * @privateRemarks
+     * TODO: The choice to always include the built-in {@link FormattedTextAsTree.(StringTextAtom:variable)} is a design decision that should be re-evaluated before stabilizing.
      */
-    export function createSchema<const TUserScope extends string, const FormatSchema extends ImplicitAllowedTypes, const ExtraAtomsSchema extends readonly LazyItem<TreeNodeSchema<string, NodeKind, TextAtom & TreeNode>>[]>(inputSchemaFactory: SchemaFactoryBeta<TUserScope>, formatSchema: FormatSchema, extraAtoms: ExtraAtomsSchema, defaultFormatInsertable: InsertableTreeFieldFromImplicitField<FormatSchema>): FormattedTextSchema<TUserScope, FormatSchema, ExtraAtomsSchema>;
+    function createSchema<const TUserScope extends string, const FormatSchema extends ImplicitAllowedTypes, const ExtraAtomsSchema extends readonly LazyItem<TreeNodeSchema<string, NodeKind, TextAtom & TreeNode>>[]>(inputSchemaFactory: SchemaFactoryBeta<TUserScope>, formatSchema: FormatSchema, extraAtoms: ExtraAtomsSchema, defaultFormatInsertable: InsertableTreeFieldFromImplicitField<FormatSchema>): FormattedTextSchema<TUserScope, FormatSchema, ExtraAtomsSchema>;
     /**
      * Portion of a string with formatting.
+     * @privateRemarks
+     * This is implemented {@link StringAtom}, but we avoid leaking the fact this is a TreeNode in the API surface to
+     * preserve more future flexibility.
      * @sealed
      * @internal
      */
-    export interface FormattedAtom<TFormat, TText> {
+    interface FormattedAtom<TFormat, TText> {
+        /**
+         * Content which is formatted.
+         */
         readonly content: TText;
+        /**
+         * Formatting which is applied to the content.
+         * @remarks
+         * Can be reassigned or deeply mutated to edit the formatting of the content.
+         */
         format: TFormat;
     }
     /**
      * Portion of a string.
+     * @remarks
+     * Additional kinds of text atoms (also known as embedded objects) which can occur inside a string can implement this.
+     * The schema for them can then be provided to {@link FormattedTextAsTree.createSchema}.
      * @internal
      */
-    export interface TextAtom {
+    interface TextAtom {
         /**
          * The content of the text atom, viewed as a string.
          */
         readonly content: string;
     }
-    const StringTextAtom_base: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.StringTextAtom", NodeKind.Object, import("../simple-tree/index.js").TreeObjectNode<{
+    /**
+     * Static factory functions for {@link FormattedTextAsTree.(StringTextAtom:variable)}.
+     * @privateRemarks
+     * We type-erase `StringTextAtom` and only provide these static factories for construction
+     * to reduce the chance of someone accidentally creating a text atom for a string other than a single unicode code point.
+     * Other strings should work, but our intention is to provide no type-safe API which can produce them, so an application can take their lack of existence as an invariant if they want.
+     * It is still however possible to produce them, like export/import round trips with editing in the middle of the process, or collaboration with an equivalent schema which doesn't enforce this invariant.
+     * @sealed
+     * @internal
+     */
+    interface StringTextAtomStatics {
         /**
-         * The underlying text content of this atom.
-         * @remarks
-         * This is typically a single Unicode code point, and thus may contain multiple UTF-16 surrogate pair code units.
-         * Using longer strings is still valid. For example, so users might store whole grapheme clusters here, or even longer sections of text.
-         * Anything combined into a single atom will be treated atomically, and can not be partially selected or formatted.
-         * Using larger atoms and splitting them as needed is NOT a recommended approach, since this will result in poor merge behavior for concurrent edits.
-         * Instead atoms should always be the smallest unit of text which will be independently selected, moved or formatted.
-         * @privateRemarks
-         * This content logically represents the whole atom's content, so using {@link EmptyKey} makes sense to help indicate that.
+         * Creates an atom from exactly one Unicode code point.
+         * @throws A {@link @fluidframework/telemetry-utils#UsageError} if `value` does not contain exactly one Unicode code character.
          */
-        readonly content: import("../simple-tree/fieldSchema.js").FieldSchema<import("../simple-tree/fieldSchema.js").FieldKind.Required, readonly [import("../simple-tree/leafNodeSchema.js").LeafSchema<"string", string>], unknown>;
-    }, "com.fluidframework.text.formatted.StringTextAtom">, object & {
-        readonly content: string;
-    }, true, {
+        fromCharacter(value: string): StringTextAtom;
         /**
-         * The underlying text content of this atom.
-         * @remarks
-         * This is typically a single Unicode code point, and thus may contain multiple UTF-16 surrogate pair code units.
-         * Using longer strings is still valid. For example, so users might store whole grapheme clusters here, or even longer sections of text.
-         * Anything combined into a single atom will be treated atomically, and can not be partially selected or formatted.
-         * Using larger atoms and splitting them as needed is NOT a recommended approach, since this will result in poor merge behavior for concurrent edits.
-         * Instead atoms should always be the smallest unit of text which will be independently selected, moved or formatted.
-         * @privateRemarks
-         * This content logically represents the whole atom's content, so using {@link EmptyKey} makes sense to help indicate that.
+         * Creates one atom for each Unicode code point in `value`.
          */
-        readonly content: import("../simple-tree/fieldSchema.js").FieldSchema<import("../simple-tree/fieldSchema.js").FieldKind.Required, readonly [import("../simple-tree/leafNodeSchema.js").LeafSchema<"string", string>], unknown>;
-    }, never, unknown>;
+        fromString(value: string): StringTextAtom[];
+    }
     /**
-     * Unit in the string representing a single character.
+     * Schema for a {@link FormattedTextAsTree.(StringTextAtom:variable)} node.
+     * @sealed
      * @internal
      */
-    export class StringTextAtom extends StringTextAtom_base implements TextAtom {
-    }
+    const StringTextAtom: StringTextAtomStatics & TreeNodeSchema<"com.fluidframework.text.formatted.StringTextAtom", NodeKind, TextAtom & TreeNode & import("../simple-tree/index.js").WithType<"com.fluidframework.text.formatted.StringTextAtom", NodeKind, unknown>, never, false>;
+    /**
+     * Node for the {@link FormattedTextAsTree.(StringTextAtom:variable)} schema.
+     * @sealed
+     * @internal
+     */
+    type StringTextAtom = ErasedNode<TextAtom, "com.fluidframework.text.formatted.StringTextAtom">;
     /**
-     * Statics for text nodes.
+     * Statics for formatted text nodes.
+     * @sealed
      * @internal
      */
-    export interface Statics<TTree> {
+    interface Statics<TTree, FormatSchema extends ImplicitAllowedTypes> {
         /**
          * Construct a node of `this` schema from a string, where each character (as defined by iterating over the string) becomes a single character in the text node.
          * @remarks This combines pairs of utf-16 surrogate code units into single characters as appropriate.
          */
-        fromString(value: string): TTree;
+        fromString(value: string, format?: InsertableTreeFieldFromImplicitField<FormatSchema>): TTree;
     }
     /**
      * Interface for a text node.
@@ -100,27 +167,32 @@ export declare namespace FormattedTextAsTree {
      *
      * @see {@link FormattedTextAsTree.Statics.fromString} for construction.
      * @see {@link FormattedTextAsTree.createSchema} for creating schemas whose nodes implement this.
+     * @sealed
      * @internal
      */
-    export interface Members<TFormatTree, TPartialFormat, TFormattedAtom, TFormattedInsert> extends TextAsTree.Members {
+    interface Members<FormatSchema extends ImplicitAllowedTypes, ExtraAtomsSchema extends readonly LazyItem<TreeNodeSchema<string, NodeKind, TextAtom & TreeNode>>[]> extends TextAsTree.Members {
         /**
-         * Format to use by default for text inserted with non-formatted APIs.
+         * {@link TextAsTree.Members.insertAt} with optional formatting to apply to all additional characters,
+         * and allowing an array of atoms instead of a string.
+         * @param format - Optional formatting to apply to all additional characters. If not specified, the default formatting (from {@link FormattedTextAsTree.createSchema}) will be used.
          * @remarks
-         * This is not persisted in the tree, and observation of it is not tracked by the tree observation tracking.
-         * @privateRemarks
-         * Opt this into observation tracking.
+         * Use {@link FormattedTextAsTree.Members.insertWithFormattingAt} if you need to specify formatting for atom independently.
+         * @override
          */
-        defaultFormat: TFormatTree;
+        insertAt(index: number, additionalCharacters: string | Iterable<TreeNodeFromImplicitAllowedTypes<TextAtomSchemas<ExtraAtomsSchema>>>, format?: InsertableTreeFieldFromImplicitField<FormatSchema>): void;
         /**
          * Gets an array type view of the characters currently in the text.
          * @remarks
          * This iterator matches the behavior of {@link (TreeArrayNode:interface)} with respect to edits during iteration.
+         *
+         * For more efficient access, use {@link FormattedTextAsTree.Members.getUniformRun} and {@link FormattedTextAsTree.Members.getString} to access ranges of characters
+         * to avoid having to inspect the formatting on every atom.
          * @privateRemarks
          * Currently this is implemented by a node and changes with the text over time.
          * We might not want to leak a node like this in the API.
          * Providing a way to index and iterate separately might be better.
          */
-        charactersWithFormatting(): readonly TFormattedAtom[];
+        charactersWithFormatting(): readonly FormattedAtom<TreeNodeFromImplicitAllowedTypes<FormatSchema>, TreeNodeFromImplicitAllowedTypes<TextAtomSchemas<ExtraAtomsSchema>>>[];
         /**
          * Insert a range of characters into the string based on character index.
          * @remarks
@@ -134,16 +206,42 @@ export declare namespace FormattedTextAsTree {
          * Another option would be to take an approach like Table,
          * where the user of the API uses a factory function to generate the schema, and can inject custom logic, like a string character iterator.
          */
-        insertWithFormattingAt(index: number, additionalCharacters: Iterable<TFormattedInsert>): void;
+        insertWithFormattingAt(index: number, additionalCharacters: Iterable<FormattedAtomInsertable<InsertableTreeNodeFromImplicitAllowedTypes<FormatSchema>, InsertableTreeNodeFromImplicitAllowedTypes<TextAtomSchemas<ExtraAtomsSchema>>>>): void;
         /**
          * Apply formatting to a range of characters based on character index.
          * @param startIndex - The starting index (inclusive) of the range to format.
          * @param endIndex - The ending index (exclusive) of the range to format.
          * @param format - The formatting to apply to the specified range.
+         * For each atom, every property of `format` will be cloned and assigned to the atom's format's corresponding subtree, overwriting any existing values for those properties.
+         * All enumerable own properties of `format` will be applied, including those with `undefined` values.
          * @remarks
          * The start and end behave the same as in {@link (TreeArrayNode:interface).removeRange}.
+         * This edits existing formatting subtrees on each atom, and only works when those atoms are object nodes.
+         *
+         * This is typically used to set some formatting property, like `bold` on a range of text without impacting other formatting properties.
+         * @privateRemarks
+         * This API is designed such that it can be optimized and improved in the future in a few different ways:
+         * 1. TODO: It can be optimized to use lower level APIs directly, bypassing the overhead of the public API surface.
+         * 2. TODO: A lower level editing API could be introduced and used to more efficiently express the edit (for example a bulk edit based on path, or a way to reuse the inserted content in multiple places instead of having to clone it before making the edit).
+         * 3. TODO: Optimize the encoding of such edits, either with a dedicated format for range edits like this and/or encoding optimizations that can compress such edits over ranges to O(1) space.
+         * 4. TODO: Preserve the range editing semantics through the whole stack to allow for better merge behavior, and make optimizations easier.
          */
-        formatRange(startIndex: number | undefined, endIndex: number | undefined, format: TPartialFormat): void;
+        formatRange(startIndex: number | undefined, endIndex: number | undefined, format: Partial<TreeNodeFromImplicitAllowedTypes<FormatSchema>>): void;
+        /**
+         * Replace formatting of a range of characters based on character index.
+         * @param startIndex - The starting index (inclusive) of the range to format.
+         * @param endIndex - The ending index (exclusive) of the range to format.
+         * @param format - The formatting to replace the formatting of the indicated range with.
+         * For each atom, `format` will be cloned and assigned to the atom's format, overwriting any existing formatting.
+         * If not specified the `defaultFormat` from {@link FormattedTextAsTree.createSchema} will be used.
+         * @remarks
+         * The start and end behave the same as in {@link (TreeArrayNode:interface).removeRange}.
+         *
+         * This is typically used to normalize formatting, like resetting the formatting of a range to default settings.
+         * @privateRemarks
+         * See notes on {@link FormattedTextAsTree.Members.formatRange} for future optimization opportunities.
+         */
+        reformat(startIndex?: number | undefined, endIndex?: number | undefined, format?: InsertableTreeFieldFromImplicitField<FormatSchema>): void;
         /**
          * Returns the length of the run of characters starting at `startIndex` which have the same formatting and atom type, up to `endIndex`.
          * @param startIndex - The starting index of the run.
@@ -177,9 +275,10 @@ export declare namespace FormattedTextAsTree {
     }
     /**
      * Insertable shape for a formatted text atom used by {@link FormattedTextAsTree.Members.insertWithFormattingAt}.
+     * @input
      * @internal
      */
-    export interface FormattedAtomInsertable<TFormat, TContent> {
+    interface FormattedAtomInsertable<TFormat, TContent> {
         readonly content: TContent;
         readonly format: TFormat;
     }
@@ -189,27 +288,22 @@ export declare namespace FormattedTextAsTree {
      * Eventually this should probably be given a better name and/or made a system type in a system namespace.
      * @internal
      */
-    export type FormattedTextSchemaIdentifier<TUserScope extends string> = ScopedSchemaName<`com.fluidframework.text.formatted<${TUserScope}>`, "Text">;
+    type FormattedTextSchemaIdentifier<TUserScope extends string> = ScopedSchemaName<`com.fluidframework.text.formatted<${TUserScope}>`, "Text">;
     /**
-     * Helper for expressing the full set of formatted text atoms for a given schema.
-     * @privateRemarks
-     * Eventually this should probably be given a better name and/or made a system type in a system namespace.
-     * @internal
-     */
-    export type FormattedTextAtoms<ExtraAtomsSchema extends readonly LazyItem<TreeNodeSchema<string, NodeKind, TextAtom & TreeNode>>[]> = readonly [typeof StringTextAtom, ...ExtraAtomsSchema];
-    /**
-     * Helper for configuring {@link FormattedTextAsTree.Members}.
-     * @privateRemarks
-     * Eventually this should probably be inlined into `FormattedTextAsTree.Members` or made a system type in a system namespace.
-     * The approach should be evaluated after settling on a redesign of the `formatRange` API as that will impact what the type parameters are.
+     * Helper for expressing the full set of text atoms for a given schema.
+     * @remarks
+     * This is just schema for the text atom {@link AllowedTypes},
+     * and does not include the actual formatting (which is higher up in the tree).
+     * @sealed
      * @internal
      */
-    export type FormattedTextMembers<FormatSchema extends ImplicitAllowedTypes, ExtraAtomsSchema extends readonly LazyItem<TreeNodeSchema<string, NodeKind, TextAtom & TreeNode>>[]> = Members<TreeFieldFromImplicitField<FormatSchema>, Partial<TreeNodeFromImplicitAllowedTypes<FormatSchema>>, FormattedAtom<TreeNodeFromImplicitAllowedTypes<FormatSchema>, TreeNodeFromImplicitAllowedTypes<FormattedTextAtoms<ExtraAtomsSchema>>>, FormattedAtomInsertable<InsertableTreeNodeFromImplicitAllowedTypes<FormatSchema>, InsertableTreeNodeFromImplicitAllowedTypes<FormattedTextAtoms<ExtraAtomsSchema>>>>;
+    type TextAtomSchemas<ExtraAtomsSchema extends readonly LazyItem<TreeNodeSchema<string, NodeKind, TextAtom & TreeNode>>[]> = readonly [typeof StringTextAtom, ...ExtraAtomsSchema];
     /**
      * A generic type for a formatted text schema.
+     * @sealed
      * @internal
      */
-    export type FormattedTextSchema<TUserScope extends string, FormatSchema extends ImplicitAllowedTypes, ExtraAtomsSchema extends readonly LazyItem<TreeNodeSchema<string, NodeKind, TextAtom & TreeNode>>[]> = Statics<ErasedNode<FormattedTextMembers<FormatSchema, ExtraAtomsSchema>, FormattedTextSchemaIdentifier<TUserScope>>> & ErasedSchemaSubclassable<FormattedTextMembers<FormatSchema, ExtraAtomsSchema>, FormattedTextSchemaIdentifier<TUserScope>>;
-    export {};
+    type FormattedTextSchema<TUserScope extends string, FormatSchema extends ImplicitAllowedTypes, ExtraAtomsSchema extends readonly LazyItem<TreeNodeSchema<string, NodeKind, TextAtom & TreeNode>>[]> = Statics<ErasedNode<Members<FormatSchema, ExtraAtomsSchema>, FormattedTextSchemaIdentifier<TUserScope>>, FormatSchema> & ErasedSchemaSubclassable<Members<FormatSchema, ExtraAtomsSchema>, FormattedTextSchemaIdentifier<TUserScope>>;
 }
+export {};
 //# sourceMappingURL=textDomainFormatted.d.ts.map

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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"}