@fluidframework/tree 2.110.0 → 2.111.0

package/dist/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/dist/text/textDomainFormatted.js

@@ -13,287 +13,301 @@ const index_js_3 = require("../shared-tree/index.js");
 const index_js_4 = require("../simple-tree/index.js");
 const index_js_5 = require("../util/index.js");
 const textDomain_js_1 = require("./textDomain.js");
-const sf = new index_js_4.SchemaFactoryAlpha("com.fluidframework.text.formatted");
-class TextNode extends sf.object("Text", {
-    content: index_js_4.SchemaFactory.required([() => StringArray], { key: index_js_1.EmptyKey }),
-}) {
-    constructor() {
-        super(...arguments);
-        this.defaultFormat = new FormattedTextAsTree.CharacterFormat(defaultFormat);
-    }
-    insertAt(index, additionalCharacters) {
-        this.content.insertAt(index, index_js_4.TreeArrayNode.spread(textAtomsFromString(additionalCharacters, this.defaultFormat)));
-    }
-    removeRange(index, end) {
-        this.content.removeRange(index, end);
-    }
-    characters() {
-        return (0, index_js_5.mapIterable)(this.content, (atom) => atom.content.content);
-    }
-    charactersCopy() {
-        const result = this.content.charactersCopy();
-        (0, internal_1.debugAssert)(() => (0, internal_1.compareArrays)(result, this.charactersCopy_reference()) ||
-            "invalid charactersCopy optimizations");
-        return result;
-    }
-    characterCount() {
-        return this.content.length;
-    }
-    fullString() {
-        const result = this.content.fullString();
-        (0, internal_1.debugAssert)(() => result === this.fullString_reference() || "invalid fullString optimizations");
-        return result;
-    }
-    /**
-     * A non-optimized reference implementation of fullString.
-     */
-    fullString_reference() {
-        return [...this.characters()].join("");
-    }
+/**
+ * Sets up scope for formatted text schema built-in types.
+ * @remarks User-provided factory scoping will be applied as `com.fluidframework.text.formatted<user-scope>`.
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type -- Inferring is the most practical option here
+function createFormattedScopedFactory(inputSchemaFactory) {
+    return (0, index_js_4.createCustomizedFluidFrameworkScopedFactory)(inputSchemaFactory, "text.formatted");
+}
+/**
+ * Schema factory for formatted text types which are not generic.
+ */
+const sfStatic = new index_js_4.SchemaFactoryAlpha("com.fluidframework.text.formatted");
+const formatKey = (0, index_js_5.brand)("format");
+/**
+ * A collection of text related types, schema and utilities for working with text beyond the basic {@link SchemaStatics.string}.
+ * @remarks
+ * This is generic over formatting an embedded object/atom types.
+ * See {@link FormattedTextAsTreeDefault} for a default parameterization.
+ * @privateRemarks
+ * TODO:
+ * - Add more comprehensive tests for generic parameterizations other than default.
+ * - Sort out API around overwriting subsets of formatting information.
+ * @internal
+ */
+var FormattedTextAsTree;
+(function (FormattedTextAsTree) {
     /**
-     * Unoptimized trivially correct implementation of charactersCopy.
+     * Factory for formatted text schema as a function of the formatting and the embedded object (atom) types.
      */
-    charactersCopy_reference() {
-        return [...this.characters()];
-    }
-    static fromString(value, format) {
-        // Constructing an ArrayNode from an iterator is supported, so creating an array from the iterable of characters seems like it's not necessary here,
-        // but to reduce the risk of incorrect data interpretation, we actually ban this in the special case where the iterable is a string directly, which is the case here.
-        // Thus the array construction here is necessary to avoid a runtime error.
-        return new TextNode({
-            content: [
-                ...textAtomsFromString(value, format ?? new FormattedTextAsTree.CharacterFormat(defaultFormat)),
-            ],
-        });
-    }
-    charactersWithFormatting() {
-        return this.content;
-    }
-    insertWithFormattingAt(index, additionalCharacters) {
-        this.content.insertAt(index, index_js_4.TreeArrayNode.spread(additionalCharacters));
-    }
-    formatRange(start, end, format) {
-        const formatStart = start ?? 0;
-        (0, index_js_5.validateIndex)(formatStart, this.content, "FormattedTextAsTree.formatRange", true);
-        const formatEnd = Math.min(this.content.length, end ?? this.content.length);
-        (0, index_js_5.validateIndexRange)(formatStart, formatEnd, this.content, "FormattedTextAsTree.formatRange");
-        const branch = index_js_3.TreeAlpha.branch(this);
-        const applyFormatting = () => {
-            for (let i = formatStart; i < formatEnd; i++) {
-                const atom = this.content[i];
-                if (atom === undefined) {
-                    throw new internal_2.UsageError("Index out of bounds while formatting text range.");
-                }
-                for (const [key, value] of Object.entries(format)) {
-                    // Object.entries should only return string keyed enumerable own properties.
-                    // The TypeScript typing does not account for this, and thus this assertion is necessary for this code to compile.
-                    (0, internal_1.assert)(typeof key === "string", 0xcc8 /* Object.entries returned a non-string key. */);
-                    const f = FormattedTextAsTree.CharacterFormat.fields.get(key);
-                    if (f === undefined) {
-                        throw new internal_2.UsageError(`Unknown format key: ${key}`);
+    function createSchema(inputSchemaFactory, formatSchema, extraAtoms, defaultFormatInsertable) {
+        const atoms = [StringTextAtom, ...extraAtoms];
+        const sf = createFormattedScopedFactory(inputSchemaFactory);
+        class TextNode extends sf.object("Text", {
+            content: index_js_4.SchemaFactory.required([() => StringArray], { key: index_js_1.EmptyKey }),
+        }) {
+            constructor() {
+                super(...arguments);
+                this.defaultFormat = index_js_4.TreeBeta.create(formatSchema, defaultFormatInsertable);
+            }
+            insertAt(index, additionalCharacters) {
+                this.content.insertAt(index, index_js_4.TreeArrayNode.spread(textAtomsFromString(additionalCharacters, this.defaultFormat)));
+            }
+            removeRange(index, end) {
+                this.content.removeRange(index, end);
+            }
+            characters() {
+                return (0, index_js_5.mapIterable)(this.content, (atom) => atom.content.content);
+            }
+            charactersCopy() {
+                const result = this.content.charactersCopy();
+                (0, internal_1.debugAssert)(() => (0, internal_1.compareArrays)(result, this.charactersCopy_reference()) ||
+                    "invalid charactersCopy optimizations");
+                return result;
+            }
+            characterCount() {
+                return this.content.length;
+            }
+            fullString() {
+                const result = this.content.fullString();
+                (0, internal_1.debugAssert)(() => result === this.fullString_reference() || "invalid fullString optimizations");
+                return result;
+            }
+            /**
+             * A non-optimized reference implementation of fullString.
+             */
+            fullString_reference() {
+                return [...this.characters()].join("");
+            }
+            /**
+             * Unoptimized trivially correct implementation of charactersCopy.
+             */
+            charactersCopy_reference() {
+                return [...this.characters()];
+            }
+            static fromString(value, format) {
+                // Use `this` rather than `TextNode` so the more derived schema class is constructed when using this as a static on a subclass.
+                return new this({
+                    content: [
+                        // Constructing an ArrayNode from an iterator is supported, so creating an array from the iterable of characters seems like it's not necessary here,
+                        // but to reduce the risk of incorrect data interpretation, we actually ban this in the special case where the iterable is a string directly, which is the case here.
+                        // Thus the array construction here is necessary to avoid a runtime error.
+                        ...textAtomsFromString(value, format ?? index_js_4.TreeBeta.create(formatSchema, defaultFormatInsertable)),
+                    ],
+                });
+            }
+            charactersWithFormatting() {
+                return this.content;
+            }
+            insertWithFormattingAt(index, additionalCharacters) {
+                this.content.insertAt(index, index_js_4.TreeArrayNode.spread(additionalCharacters));
+            }
+            formatRange(start, end, format) {
+                const formatStart = start ?? 0;
+                (0, index_js_5.validateIndex)(formatStart, this.content, "FormattedTextAsTree.formatRange", true);
+                const formatEnd = Math.min(this.content.length, end ?? this.content.length);
+                (0, index_js_5.validateIndexRange)(formatStart, formatEnd, this.content, "FormattedTextAsTree.formatRange");
+                const fieldFormats = Object.entries(format);
+                index_js_3.TreeAlpha.context(this).runTransaction(() => {
+                    for (let i = formatStart; i < formatEnd; i++) {
+                        const atom = this.content[i];
+                        // Range validated above, so this should never fail.
+                        (0, internal_1.assert)(atom !== undefined, 0xd08 /* Index out of bounds while formatting text range. */);
+                        const formatNode = atom.format;
+                        const atomFormatSchema = index_js_3.Tree.schema(formatNode);
+                        if (!(0, index_js_4.isObjectNodeSchema)(atomFormatSchema)) {
+                            // TODO: redesign this API to work with all allowed FormatSchema types.
+                            throw new internal_2.UsageError("formatRange currently only supports object nodes for the format.");
+                        }
+                        for (const [key, value] of fieldFormats) {
+                            // Object.entries should only return string keyed enumerable own properties.
+                            // The TypeScript typing does not account for this, and thus this assertion is necessary for this code to compile.
+                            (0, internal_1.assert)(typeof key === "string", 0xcc8 /* Object.entries returned a non-string key. */);
+                            const field = atomFormatSchema.fields.get(key);
+                            if (field === undefined) {
+                                throw new internal_2.UsageError(`Unknown format key: ${key}`);
+                            }
+                            // Ensures that if the input is a node, it is cloned before being inserted into the tree.
+                            const clonedValue = index_js_4.TreeBeta.clone(index_js_4.TreeBeta.create(field, value));
+                            formatNode[key] = clonedValue;
+                        }
                     }
-                    // Ensures that if the input is a node, it is cloned before being inserted into the tree.
-                    atom.format[key] = index_js_4.TreeBeta.clone(index_js_4.TreeBeta.create(f, value));
-                }
+                });
+            }
+            /**
+             * Returns the {@link  FormattedTextAsTree.TextAtom.content} at the given atom index, or `undefined` if out of bounds.
+             */
+            getAtomCharacterAt(index) {
+                const atom = this.content[index];
+                if (atom === undefined)
+                    return undefined;
+                return atom.content.content;
+            }
+            onCharactersChanged(callback) {
+                return index_js_3.TreeAlpha.on(this.content, "nodeChanged", ({ delta }) => (0, textDomain_js_1.processCharactersChangedDelta)(delta, (index) => this.getAtomCharacterAt(index), callback));
+            }
+            onContentChanged(callback) {
+                return index_js_3.TreeAlpha.on(this.content, "treeChanged", ({ delta }) => (0, textDomain_js_1.processCharactersChangedDelta)(delta, (index) => this.getAtomCharacterAt(index), callback));
+            }
+            getUniformRun(startIndex, endIndex) {
+                return this.content.getUniformRun(startIndex, endIndex);
+            }
+            getString(startIndex, endIndex) {
+                return this.content.getString(startIndex, endIndex);
             }
-        };
-        if (branch === undefined) {
-            // If this node does not have a corresponding branch, then it is unhydrated.
-            // I.e., it is not part of a collaborative session yet.
-            // Therefore, we don't need to run the edits as a transaction.
-            // Note: for unhydrated nodes each atom edit fires a separate `treeChanged` event,
-            // so formatting N atoms will produce N callbacks on `onContentChanged` subscribers
-            // instead of the single callback that hydrated (transacted) edits produce.
-            // `withBufferedTreeEvents` is not a viable mitigation here: when more than one atom's
-            // `format` field changes within the same buffered scope, the kernel's per-field
-            // dedup logic discards the delta (see `treeNodeKernel.ts` `#fieldMarksBuffer`),
-            // which is worse for incremental consumers than N well-formed callbacks.
-            // Use `runTransaction` on a hydrated node (i.e. after inserting into the document)
-            // if batched events matter.
-            applyFormatting();
         }
-        else {
-            // Wrap all formatting operations in a single transaction for atomicity.
-            branch.runTransaction(() => {
-                applyFormatting();
+        function textAtomsFromString(value, format) {
+            const result = (0, index_js_5.mapIterable)((0, textDomain_js_1.charactersFromString)(value), (char) => {
+                const textAtom = new StringTextAtom({ content: char });
+                const data = {
+                    content: textAtom,
+                    format: index_js_4.TreeBeta.clone(format),
+                };
+                return new StringAtom(data); // Generic break type safety here. TODO: try and make safer.
             });
+            return result;
         }
-    }
-    /**
-     * Returns the character string at the given atom index, or `undefined` if out of bounds.
-     * @remarks
-     * Line atoms expand to `"\n"`; text atoms return their underlying code point(s).
-     */
-    getAtomCharacterAt(index) {
-        const atom = this.content[index];
-        if (atom === undefined)
-            return undefined;
-        return atom.content instanceof FormattedTextAsTree.StringLineAtom
-            ? "\n"
-            : atom.content.content;
-    }
-    onCharactersChanged(callback) {
-        return index_js_3.TreeAlpha.on(this.content, "nodeChanged", ({ delta }) => (0, textDomain_js_1.processCharactersChangedDelta)(delta, (index) => this.getAtomCharacterAt(index), callback));
-    }
-    onContentChanged(callback) {
-        return index_js_3.TreeAlpha.on(this.content, "treeChanged", ({ delta }) => (0, textDomain_js_1.processCharactersChangedDelta)(delta, (index) => this.getAtomCharacterAt(index), callback));
-    }
-    getUniformRun(startIndex, endIndex) {
-        return this.content.getUniformRun(startIndex, endIndex);
-    }
-    getString(startIndex, endIndex) {
-        return this.content.getString(startIndex, endIndex);
-    }
-}
-const defaultFormat = {
-    bold: false,
-    italic: false,
-    underline: false,
-    size: 12,
-    font: "Arial",
-};
-const formatKey = (0, index_js_5.brand)("format");
-function textAtomsFromString(value, format) {
-    const result = (0, index_js_5.mapIterable)((0, textDomain_js_1.charactersFromString)(value), (char) => new FormattedTextAsTree.StringAtom({
-        content: { content: char },
-        format: index_js_4.TreeBeta.clone(format),
-    }));
-    return result;
-}
-class StringArray extends sf.array("StringArray", [() => FormattedTextAsTree.StringAtom]) {
-    withBorrowedSequenceCursor(f) {
-        const innerNode = (0, index_js_4.getInnerNode)(this);
-        // Since the cursor will be used to read content from the tree and won't track observations,
-        // treat it as if it observed the whole subtree.
-        index_js_2.currentObserver?.observeNodeDeep(innerNode);
-        const cursor = innerNode.borrowCursor();
-        cursor.enterField(index_js_1.EmptyKey);
-        const result = f(cursor);
-        cursor.exitField();
-        return result;
-    }
-    getCharactersSubarray(startIndex, endIndex) {
-        return this.withBorrowedSequenceCursor((cursor) => {
-            const result = [];
-            (0, index_js_1.forEachNodeSubsequence)(cursor, startIndex, endIndex, () => {
-                (0, internal_1.debugAssert)(() => cursor.type === FormattedTextAsTree.StringAtom.identifier ||
-                    "invalid fullString type optimizations");
+        class StringArray extends sf.array("StringArray", [() => StringAtom]) {
+            withBorrowedSequenceCursor(f) {
+                const innerNode = (0, index_js_4.getInnerNode)(this);
+                // Since the cursor will be used to read content from the tree and won't track observations,
+                // treat it as if it observed the whole subtree.
+                index_js_2.currentObserver?.observeNodeDeep(innerNode);
+                const cursor = innerNode.borrowCursor();
                 cursor.enterField(index_js_1.EmptyKey);
-                cursor.enterNode(0);
-                let content;
-                switch (cursor.type) {
-                    case FormattedTextAsTree.StringTextAtom.identifier: {
+                const result = f(cursor);
+                cursor.exitField();
+                return result;
+            }
+            getCharactersSubarray(startIndex, endIndex) {
+                const slowPathIndexes = [];
+                const result = [];
+                this.withBorrowedSequenceCursor((cursor) => {
+                    (0, index_js_1.forEachNodeSubsequence)(cursor, startIndex, endIndex, () => {
+                        (0, internal_1.debugAssert)(() => cursor.type === StringAtom.identifier ||
+                            "invalid fullString type optimizations");
                         cursor.enterField(index_js_1.EmptyKey);
                         cursor.enterNode(0);
-                        content = cursor.value;
-                        (0, internal_1.debugAssert)(() => typeof content === "string" || "invalid fullString type optimizations");
+                        let content;
+                        switch (cursor.type) {
+                            case StringTextAtom.identifier: {
+                                cursor.enterField(index_js_1.EmptyKey);
+                                cursor.enterNode(0);
+                                content = cursor.value;
+                                (0, internal_1.debugAssert)(() => typeof content === "string" || "invalid fullString type optimizations");
+                                cursor.exitNode();
+                                cursor.exitField();
+                                break;
+                            }
+                            // TODO: we could optimize this for constant cases via an optional symbol on the atom schema holding the constant.
+                            // A less general optimization could just include cases for build in types with constant values
+                            // (like below commented code: currently this would cause a cyclical dependency but could be refactored).
+                            // case FormattedTextAsTree.StringLineAtom.identifier: {
+                            // 	content = "\n";
+                            // 	break;
+                            // }
+                            default: {
+                                slowPathIndexes.push(result.length);
+                                content = ""; // Placeholder for slow path content
+                            }
+                        }
                         cursor.exitNode();
                         cursor.exitField();
-                        break;
-                    }
-                    case FormattedTextAsTree.StringLineAtom.identifier: {
-                        content = "\n";
-                        break;
-                    }
-                    default: {
-                        (0, internal_1.fail)(0xcde /* Unsupported node type in text array */, () => `${cursor.type}`);
-                    }
+                        result.push(content);
+                    });
+                });
+                // Fill in slow path cases not optimized above.
+                for (const index of slowPathIndexes) {
+                    const node = this[index + startIndex] ??
+                        (0, internal_1.fail)(0xd09 /* getCharactersSubarray failed to find index after index range was checked */);
+                    result[index] = node.content.content;
                 }
-                cursor.exitNode();
-                cursor.exitField();
-                result.push(content);
-            });
-            return result;
-        });
-    }
-    charactersCopy() {
-        return this.getCharactersSubarray(0, this.length);
-    }
-    fullString() {
-        return this.charactersCopy().join("");
-    }
-    getString(startIndex, endIndex = this.length) {
-        (0, index_js_5.validateIndexRange)(startIndex, endIndex, this, "FormattedTextAsTree.getString");
-        return this.getCharactersSubarray(startIndex, endIndex).join("");
-    }
-    getUniformRun(startIndex, endIndex = this.length) {
-        (0, index_js_5.validateIndexRange)(startIndex, endIndex, this, "FormattedTextAsTree.getUniformRun");
-        if (endIndex === startIndex) {
-            throw new internal_2.UsageError("endIndex must be greater than startIndex for getUniformRun.");
-        }
-        const arrayLength = this.length;
-        return this.withBorrowedSequenceCursor((cursor) => {
-            cursor.enterNode(startIndex);
-            // Capture the content type of the first atom
-            cursor.enterField(index_js_1.EmptyKey);
-            cursor.enterNode(0);
-            const contentType = cursor.type;
-            cursor.exitNode();
-            cursor.exitField();
-            // Build a comparator from the format subtree of the first atom
-            // This compares by field key
-            cursor.enterField(formatKey);
-            cursor.enterNode(0);
-            const formatComparator = (0, index_js_2.buildNodeComparator)(cursor);
-            cursor.exitNode();
-            cursor.exitField();
-            let runLength = 1;
-            const limit = Math.min(endIndex, arrayLength) - startIndex;
-            while (runLength < limit && cursor.nextNode()) {
-                // Compare atom type
-                cursor.enterField(index_js_1.EmptyKey);
-                cursor.enterNode(0);
-                const typeMatches = cursor.type === contentType;
-                cursor.exitNode();
-                cursor.exitField();
-                if (!typeMatches) {
-                    break;
-                }
-                // Compare format subtree using the compiled comparator
-                cursor.enterField(formatKey);
-                cursor.enterNode(0);
-                const formatMatches = formatComparator(cursor);
-                cursor.exitNode();
-                cursor.exitField();
-                if (formatMatches !== true) {
-                    break;
+                return result;
+            }
+            charactersCopy() {
+                return this.getCharactersSubarray(0, this.length);
+            }
+            fullString() {
+                return this.charactersCopy().join("");
+            }
+            getString(startIndex, endIndex = this.length) {
+                (0, index_js_5.validateIndexRange)(startIndex, endIndex, this, "FormattedTextAsTree.getString");
+                return this.getCharactersSubarray(startIndex, endIndex).join("");
+            }
+            getUniformRun(startIndex, endIndex = this.length) {
+                (0, index_js_5.validateIndexRange)(startIndex, endIndex, this, "FormattedTextAsTree.getUniformRun");
+                if (endIndex === startIndex) {
+                    throw new internal_2.UsageError("endIndex must be greater than startIndex for getUniformRun.");
                 }
-                runLength++;
+                const arrayLength = this.length;
+                return this.withBorrowedSequenceCursor((cursor) => {
+                    cursor.enterNode(startIndex);
+                    // Capture the content type of the first atom
+                    cursor.enterField(index_js_1.EmptyKey);
+                    cursor.enterNode(0);
+                    const contentType = cursor.type;
+                    cursor.exitNode();
+                    cursor.exitField();
+                    // Build a comparator from the format subtree of the first atom
+                    // This compares by field key
+                    cursor.enterField(formatKey);
+                    cursor.enterNode(0);
+                    const formatComparator = (0, index_js_2.buildNodeComparator)(cursor);
+                    cursor.exitNode();
+                    cursor.exitField();
+                    let runLength = 1;
+                    const limit = Math.min(endIndex, arrayLength) - startIndex;
+                    while (runLength < limit && cursor.nextNode()) {
+                        // Compare atom type
+                        cursor.enterField(index_js_1.EmptyKey);
+                        cursor.enterNode(0);
+                        const typeMatches = cursor.type === contentType;
+                        cursor.exitNode();
+                        cursor.exitField();
+                        if (!typeMatches) {
+                            break;
+                        }
+                        // Compare format subtree using the compiled comparator
+                        cursor.enterField(formatKey);
+                        cursor.enterNode(0);
+                        const formatMatches = formatComparator(cursor);
+                        cursor.exitNode();
+                        cursor.exitField();
+                        if (formatMatches !== true) {
+                            break;
+                        }
+                        runLength++;
+                    }
+                    cursor.exitNode();
+                    return runLength;
+                });
             }
-            cursor.exitNode();
-            return runLength;
-        });
-    }
-}
-/**
- * A collection of text related types, schema and utilities for working with text beyond the basic {@link SchemaStatics.string}.
- * @privateRemarks
- * This has hard-coded assumptions about what kind of embedded content and what kind of formatting is supported.
- * We will want to generalize this with a more generic schema factory function like with table.
- * Then either that and/or the output from it can be package exported.
- * This version is just an initial prototype.
- * @internal
- */
-var FormattedTextAsTree;
-(function (FormattedTextAsTree) {
-    /**
-     * Formatting options for characters.
-     * @internal
-     */
-    class CharacterFormat extends sf.objectAlpha("CharacterFormat", {
-        bold: index_js_4.SchemaFactory.boolean,
-        italic: index_js_4.SchemaFactory.boolean,
-        underline: index_js_4.SchemaFactory.boolean,
-        size: index_js_4.SchemaFactory.number,
-        font: index_js_4.SchemaFactory.string,
-    }) {
+        }
+        /**
+         * A unit of the text, with formatting.
+         */
+        class StringAtom extends sf.object("StringAtom", {
+            content: index_js_4.SchemaFactory.required(atoms, { key: index_js_1.EmptyKey }),
+            format: index_js_4.SchemaFactory.required(formatSchema),
+        }) {
+        }
+        /**
+         * Schema for a text node.
+         * @remarks
+         * See {@link FormattedTextAsTree.Members} for the API.
+         * See {@link FormattedTextAsTree.Statics} for static APIs on this Schema, including construction.
+         */
+        const Tree = (0, index_js_4.eraseSchemaDetailsSubclassable)()(TextNode);
+        return Tree;
     }
-    FormattedTextAsTree.CharacterFormat = CharacterFormat;
+    FormattedTextAsTree.createSchema = createSchema;
     /**
      * Unit in the string representing a single character.
      * @internal
      */
-    class StringTextAtom extends sf.object("StringTextAtom", {
+    class StringTextAtom extends sfStatic.object("StringTextAtom", {
         /**
          * The underlying text content of this atom.
          * @remarks
@@ -309,66 +323,5 @@ var FormattedTextAsTree;
     }) {
     }
     FormattedTextAsTree.StringTextAtom = StringTextAtom;
-    /**
-     * Tag with which a line in text can be formatted from HTML.
-     * @internal
-     */
-    FormattedTextAsTree.LineTag = (0, index_js_4.enumFromStrings)(sf.scopedFactory("lineTag"), [
-        "h1",
-        "h2",
-        "h3",
-        "h4",
-        "h5",
-        "li",
-        "ol",
-        "checked",
-        "unchecked",
-        "blockquote",
-        "codeBlock",
-    ]);
-    /**
-     * Unit in the string representing a new line character with line formatting.
-     * @remarks
-     * This aligns with how Quill represents line formatting.
-     * Quill formats line attributes (headers, list, blockquote, etc... ) on the newline character
-     * and only lines using this atom can have line-specific formatting.
-     * The optional indent level mirrors Quill's indent attribute,
-     * which is applies to the line before the line break.
-     * Any tagged line can be indented independently.
-     * @internal
-     */
-    class StringLineAtom extends sf.object("StringLineAtom", {
-        tag: FormattedTextAsTree.LineTag.schema,
-        indent: index_js_4.SchemaFactory.number,
-    }) {
-        constructor() {
-            super(...arguments);
-            this.content = "\n";
-        }
-    }
-    FormattedTextAsTree.StringLineAtom = StringLineAtom;
-    /**
-     * Types of "atoms" that make up the text.
-     * @internal
-     */
-    FormattedTextAsTree.StringAtomContent = [StringTextAtom, StringLineAtom];
-    /**
-     * A unit of the text, with formatting.
-     * @internal
-     */
-    class StringAtom extends sf.object("StringAtom", {
-        content: index_js_4.SchemaFactory.required(FormattedTextAsTree.StringAtomContent, { key: index_js_1.EmptyKey }),
-        format: CharacterFormat,
-    }) {
-    }
-    FormattedTextAsTree.StringAtom = StringAtom;
-    /**
-     * Schema for a text node.
-     * @remarks
-     * See {@link FormattedTextAsTree.Members} for the API.
-     * See {@link FormattedTextAsTree.Statics} for static APIs on this Schema, including construction.
-     * @internal
-     */
-    FormattedTextAsTree.Tree = (0, index_js_4.eraseSchemaDetails)()(TextNode);
 })(FormattedTextAsTree || (exports.FormattedTextAsTree = FormattedTextAsTree = {}));
 //# sourceMappingURL=textDomainFormatted.js.map