@itwin/core-backend 5.1.0-dev.29 → 5.1.0-dev.31

package/lib/esm/test/annotations/TextAnnotation.test.js

@@ -2,993 +2,33 @@
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
-import { assert, expect } from "chai";
-import { computeGraphemeOffsets, layoutTextBlock } from "../../TextAnnotationLayout";
-import { Geometry, Range2d } from "@itwin/core-geometry";
-import { ColorDef, FontType, FractionRun, LineBreakRun, TextAnnotation, TextBlock, TextRun, TextStyleSettings } from "@itwin/core-common";
-import { TextAnnotation2d, TextAnnotation3d } from "../../TextAnnotationElement";
-import { produceTextAnnotationGeometry } from "../../TextAnnotationGeometry";
+import { expect } from "chai";
+import { Angle, Point3d, Range2d, Range3d, YawPitchRollAngles } from "@itwin/core-geometry";
+import { Code, ColorDef, FractionRun, SubCategoryAppearance, TextAnnotation, TextBlock, TextRun } from "@itwin/core-common";
+import { StandaloneDb } from "../../IModelDb";
+import { TextAnnotation2d, TextAnnotation3d } from "../../annotations/TextAnnotationElement";
 import { IModelTestUtils } from "../IModelTestUtils";
-import { Id64, ProcessDetector } from "@itwin/core-bentley";
+import { Subject } from "../../Element";
+import { Guid, Id64 } from "@itwin/core-bentley";
+import { DefinitionModel } from "../../Model";
+import { DrawingCategory, SpatialCategory } from "../../Category";
+import { DisplayStyle2d, DisplayStyle3d } from "../../DisplayStyle";
+import { CategorySelector, DrawingViewDefinition, ModelSelector, SpatialViewDefinition } from "../../ViewDefinition";
+import { FontFile } from "../../FontFile";
 function computeTextRangeAsStringLength(args) {
     const range = new Range2d(0, 0, args.chars.length, args.lineHeight);
     return { layout: range, justification: range };
 }
-function doLayout(textBlock, args) {
-    const layout = layoutTextBlock({
-        textBlock,
-        iModel: {},
-        findTextStyle: args?.findTextStyle ?? (() => TextStyleSettings.defaults),
-        findFontId: args?.findFontId ?? (() => 0),
-        computeTextRange: args?.computeTextRange ?? computeTextRangeAsStringLength,
-    });
-    return layout;
-}
-function makeTextRun(content, styleName = "") {
-    return TextRun.create({ content, styleName });
-}
-function isIntlSupported() {
-    // Node in the mobile add-on does not include Intl, so this test fails. Right now, mobile
-    // users are not expected to do any editing, but long term we will attempt to find a better
-    // solution.
-    return !ProcessDetector.isMobileAppBackend;
-}
-describe("layoutTextBlock", () => {
-    it("resolves TextStyleSettings from combination of TextBlock and Run", () => {
-        const textBlock = TextBlock.create({ styleName: "block", styleOverrides: { widthFactor: 34, color: 0x00ff00 } });
-        const run0 = TextRun.create({ content: "run0", styleName: "run", styleOverrides: { lineHeight: 56, color: 0xff0000 } });
-        const run1 = TextRun.create({ content: "run1", styleName: "run", styleOverrides: { widthFactor: 78, fontName: "run1" } });
-        textBlock.appendRun(run0);
-        textBlock.appendRun(run1);
-        const tb = doLayout(textBlock, {
-            findTextStyle: (name) => TextStyleSettings.fromJSON(name === "block" ? { lineSpacingFactor: 12, fontName: "block" } : { lineSpacingFactor: 99, fontName: "run" }),
-        });
-        expect(tb.lines.length).to.equal(1);
-        expect(tb.lines[0].runs.length).to.equal(2);
-        const s0 = tb.lines[0].runs[0].style;
-        expect(s0.lineHeight).to.equal(1);
-        expect(s0.lineSpacingFactor).to.equal(12);
-        expect(s0.widthFactor).to.equal(34);
-        expect(s0.fontName).to.equal("run");
-        expect(s0.color).to.equal(0xff0000);
-        const s1 = tb.lines[0].runs[1].style;
-        expect(s1.widthFactor).to.equal(34);
-        expect(s1.lineSpacingFactor).to.equal(12);
-        expect(s1.lineHeight).to.equal(1);
-        expect(s1.fontName).to.equal("run1");
-        expect(s1.color).to.equal("subcategory");
-    });
-    it("aligns text to center based on height of stacked fraction", () => {
-        const textBlock = TextBlock.create({ styleName: "" });
-        const fractionRun = FractionRun.create({ numerator: "1", denominator: "2", styleName: "fraction" });
-        const textRun = TextRun.create({ content: "text", styleName: "text" });
-        textBlock.appendRun(fractionRun);
-        textBlock.appendRun(textRun);
-        const layout = doLayout(textBlock);
-        const fractionLayout = layout.lines[0].runs[0];
-        const textLayout = layout.lines[0].runs[1];
-        const round = (num, numDecimalPlaces) => {
-            const mult = Math.pow(100, numDecimalPlaces);
-            return Math.round(num * mult) / mult;
-        };
-        expect(textLayout.range.yLength()).to.equal(1);
-        expect(round(fractionLayout.range.yLength(), 2)).to.equal(1.75);
-        expect(fractionLayout.offsetFromLine.y).to.equal(0);
-        expect(round(textLayout.offsetFromLine.y, 3)).to.equal(.375);
-    });
-    it("produces one line per paragraph if document width <= 0", () => {
-        const textBlock = TextBlock.create({ styleName: "" });
-        for (let i = 0; i < 4; i++) {
-            const layout = doLayout(textBlock);
-            if (i === 0) {
-                expect(layout.range.isNull).to.be.true;
-            }
-            else {
-                expect(layout.lines.length).to.equal(i);
-                expect(layout.range.low.x).to.equal(0);
-                expect(layout.range.low.y).to.equal(-i - (0.5 * (i - 1))); // lineSpacingFactor=0.5
-                expect(layout.range.high.x).to.equal(i * 3);
-                expect(layout.range.high.y).to.equal(0);
-            }
-            for (let l = 0; l < layout.lines.length; l++) {
-                const line = layout.lines[l];
-                expect(line.runs.length).to.equal(l + 1);
-                expect(line.range.low.x).to.equal(0);
-                expect(line.range.low.y).to.equal(0);
-                expect(line.range.high.y).to.equal(1);
-                expect(line.range.high.x).to.equal(3 * (l + 1));
-                for (const run of line.runs) {
-                    expect(run.charOffset).to.equal(0);
-                    expect(run.numChars).to.equal(3);
-                    expect(run.range.low.x).to.equal(0);
-                    expect(run.range.low.y).to.equal(0);
-                    expect(run.range.high.x).to.equal(3);
-                    expect(run.range.high.y).to.equal(1);
-                }
-            }
-            const p = textBlock.appendParagraph();
-            for (let j = 0; j <= i; j++) {
-                p.runs.push(TextRun.create({ styleName: "", content: "Run" }));
-            }
-        }
-    });
-    it("produces a new line for each LineBreakRun", () => {
-        const lineSpacingFactor = 0.5;
-        const lineHeight = 1;
-        const textBlock = TextBlock.create({ styleName: "", styleOverrides: { lineSpacingFactor, lineHeight } });
-        textBlock.appendRun(TextRun.create({ styleName: "", content: "abc" }));
-        textBlock.appendRun(LineBreakRun.create({ styleName: "" }));
-        textBlock.appendRun(TextRun.create({ styleName: "", content: "def" }));
-        textBlock.appendRun(TextRun.create({ styleName: "", content: "ghi" }));
-        textBlock.appendRun(LineBreakRun.create({ styleName: "" }));
-        textBlock.appendRun(TextRun.create({ styleName: "", content: "jkl" }));
-        const tb = doLayout(textBlock);
-        expect(tb.lines.length).to.equal(3);
-        expect(tb.lines[0].runs.length).to.equal(2);
-        expect(tb.lines[1].runs.length).to.equal(3);
-        expect(tb.lines[2].runs.length).to.equal(1);
-        expect(tb.range.low.x).to.equal(0);
-        expect(tb.range.high.x).to.equal(6);
-        expect(tb.range.high.y).to.equal(0);
-        expect(tb.range.low.y).to.equal(-(lineSpacingFactor * 2 + lineHeight * 3));
-    });
-    it("computes ranges based on custom line spacing and line height", () => {
-        const lineSpacingFactor = 2;
-        const lineHeight = 3;
-        const textBlock = TextBlock.create({ styleName: "", styleOverrides: { lineSpacingFactor, lineHeight } });
-        textBlock.appendRun(TextRun.create({ styleName: "", content: "abc" }));
-        textBlock.appendRun(LineBreakRun.create({ styleName: "" }));
-        textBlock.appendRun(TextRun.create({ styleName: "", content: "def" }));
-        textBlock.appendRun(TextRun.create({ styleName: "", content: "ghi" }));
-        textBlock.appendRun(LineBreakRun.create({ styleName: "" }));
-        textBlock.appendRun(TextRun.create({ styleName: "", content: "jkl" }));
-        const tb = doLayout(textBlock);
-        expect(tb.lines.length).to.equal(3);
-        expect(tb.lines[0].runs.length).to.equal(2);
-        expect(tb.lines[1].runs.length).to.equal(3);
-        expect(tb.lines[2].runs.length).to.equal(1);
-        // We have 3 lines each `lineHeight` high, plus 2 line breaks in between each `lineHeight*lineSpacingFactor` high.
-        expect(tb.range.low.x).to.equal(0);
-        expect(tb.range.high.x).to.equal(6);
-        expect(tb.range.high.y).to.equal(0);
-        expect(tb.range.low.y).to.equal(-(lineHeight * 3 + (lineHeight * lineSpacingFactor) * 2));
-        expect(tb.lines[0].offsetFromDocument.y).to.equal(-lineHeight);
-        expect(tb.lines[1].offsetFromDocument.y).to.equal(tb.lines[0].offsetFromDocument.y - (lineHeight + lineHeight * lineSpacingFactor));
-        expect(tb.lines[2].offsetFromDocument.y).to.equal(tb.lines[1].offsetFromDocument.y - (lineHeight + lineHeight * lineSpacingFactor));
-        expect(tb.lines.every((line) => line.offsetFromDocument.x === 0)).to.be.true;
-    });
-    it("splits paragraphs into multiple lines if runs exceed the document width", function () {
-        if (!isIntlSupported()) {
-            this.skip();
-        }
-        const textBlock = TextBlock.create({ styleName: "" });
-        textBlock.width = 6;
-        textBlock.appendRun(makeTextRun("ab"));
-        expect(doLayout(textBlock).lines.length).to.equal(1);
-        textBlock.appendRun(makeTextRun("cd"));
-        expect(doLayout(textBlock).lines.length).to.equal(1);
-        textBlock.appendRun(makeTextRun("ef"));
-        expect(doLayout(textBlock).lines.length).to.equal(1);
-        textBlock.appendRun(makeTextRun("ghi"));
-        expect(doLayout(textBlock).lines.length).to.equal(2);
-        textBlock.appendRun(makeTextRun("jklmnop"));
-        expect(doLayout(textBlock).lines.length).to.equal(3);
-        textBlock.appendRun(makeTextRun("q"));
-        expect(doLayout(textBlock).lines.length).to.equal(4);
-        textBlock.appendRun(makeTextRun("r"));
-        expect(doLayout(textBlock).lines.length).to.equal(4);
-        textBlock.appendRun(makeTextRun("stu"));
-        expect(doLayout(textBlock).lines.length).to.equal(4);
-        textBlock.appendRun(makeTextRun("vwxyz"));
-        expect(doLayout(textBlock).lines.length).to.equal(5);
-    });
-    function expectRange(width, height, range) {
-        expect(range.xLength()).to.equal(width);
-        expect(range.yLength()).to.equal(height);
-    }
-    it("computes range for wrapped lines", function () {
-        if (!isIntlSupported()) {
-            this.skip();
-        }
-        const block = TextBlock.create({ styleName: "", width: 3, styleOverrides: { lineHeight: 1, lineSpacingFactor: 0 } });
-        function expectBlockRange(width, height) {
-            const layout = doLayout(block);
-            expectRange(width, height, layout.range);
-        }
-        block.appendRun(makeTextRun("abc"));
-        expectBlockRange(3, 1);
-        block.appendRun(makeTextRun("defg"));
-        expectBlockRange(4, 2);
-        block.width = 1;
-        expectBlockRange(4, 2);
-        block.width = 8;
-        expectBlockRange(8, 1);
-        block.width = 6;
-        expectBlockRange(6, 2);
-        block.width = 10;
-        expectBlockRange(10, 1);
-        block.appendRun(makeTextRun("hijk"));
-        expectBlockRange(10, 2);
-    });
-    it("computes range for split runs", function () {
-        if (!isIntlSupported()) {
-            this.skip();
-        }
-        const block = TextBlock.create({ styleName: "", styleOverrides: { lineHeight: 1, lineSpacingFactor: 0 } });
-        function expectBlockRange(width, height) {
-            const layout = doLayout(block);
-            expectRange(width, height, layout.range);
-        }
-        const sentence = "a bc def ghij klmno";
-        expect(sentence.length).to.equal(19);
-        block.appendRun(makeTextRun(sentence));
-        block.width = 19;
-        expectBlockRange(19, 1);
-        block.width = 10;
-        expectBlockRange(10, 2);
-    });
-    it("justifies lines", function () {
-        if (!isIntlSupported()) {
-            this.skip();
-        }
-        const block = TextBlock.create({ styleName: "", styleOverrides: { lineSpacingFactor: 0 } });
-        function expectBlockRange(width, height) {
-            const layout = doLayout(block);
-            expectRange(width, height, layout.range);
-        }
-        function expectLineOffset(offset, lineIndex) {
-            const layout = doLayout(block);
-            expect(layout.lines.length).least(lineIndex + 1);
-            const line = layout.lines[lineIndex];
-            expect(line.offsetFromDocument.y).to.equal(-(lineIndex + 1));
-            expect(line.offsetFromDocument.x).to.equal(offset);
-        }
-        // Two text runs with 7 characters total.
-        block.appendRun(makeTextRun("abc"));
-        block.appendRun(makeTextRun("defg"));
-        // 1 line of text with width 0: left, right, center justification.
-        block.justification = "left";
-        expectBlockRange(7, 1);
-        expectLineOffset(0, 0);
-        block.justification = "right";
-        expectBlockRange(7, 1);
-        expectLineOffset(0, 0);
-        block.justification = "center";
-        expectBlockRange(7, 1);
-        expectLineOffset(0, 0);
-        // 1 line of text from a width greater than number of characters: left, right, center justification.
-        block.width = 10;
-        block.justification = "left";
-        expectBlockRange(10, 1);
-        expectLineOffset(0, 0);
-        block.justification = "right";
-        expectBlockRange(10, 1);
-        expectLineOffset(3, 0); // 3 = 10 - 7
-        block.justification = "center";
-        expectBlockRange(10, 1);
-        expectLineOffset(1.5, 0); // 1.5 = (10 - 7) / 2
-        // 2 line of text from a width less than number of characters: left, right, center justification.
-        block.justification = "left";
-        block.width = 4;
-        expectBlockRange(4, 2);
-        expectLineOffset(0, 0);
-        expectLineOffset(0, 1);
-        block.justification = "right";
-        expectBlockRange(4, 2);
-        expectLineOffset(1, 0);
-        expectLineOffset(0, 1);
-        block.justification = "center";
-        expectBlockRange(4, 2);
-        expectLineOffset(0.5, 0);
-        expectLineOffset(0, 1);
-        // Testing text longer the the width of the text block.
-        block.width = 2;
-        block.justification = "left";
-        expectBlockRange(4, 2);
-        expectLineOffset(0, 0);
-        expectLineOffset(0, 1);
-        block.justification = "right";
-        expectBlockRange(4, 2);
-        expectLineOffset(-1, 0);
-        expectLineOffset(-2, 1);
-        block.appendRun(makeTextRun("123456789"));
-        expectBlockRange(9, 3);
-        expectLineOffset(-1, 0);
-        expectLineOffset(-2, 1);
-        expectLineOffset(-7, 2);
-        block.justification = "center";
-        expectBlockRange(9, 3);
-        expectLineOffset(-0.5, 0);
-        expectLineOffset(-1, 1);
-        expectLineOffset(-3.5, 2);
-    });
-    function expectLines(input, width, expectedLines) {
-        const textBlock = TextBlock.create({ styleName: "" });
-        textBlock.width = width;
-        const run = makeTextRun(input);
-        textBlock.appendRun(run);
-        const layout = doLayout(textBlock);
-        expect(layout.lines.every((line) => line.runs.every((r) => r.source === run))).to.be.true;
-        const actual = layout.lines.map((line) => line.runs.map((runLayout) => runLayout.source.content.substring(runLayout.charOffset, runLayout.charOffset + runLayout.numChars)).join(""));
-        expect(actual).to.deep.equal(expectedLines);
-        return layout;
-    }
-    it("splits a single TextRun at word boundaries if it exceeds the document width", function () {
-        if (!isIntlSupported()) {
-            this.skip();
-        }
-        expectLines("a bc def ghij klmno pqrstu vwxyz", 5, [
-            "a bc ",
-            "def ",
-            "ghij ",
-            "klmno ",
-            "pqrstu ",
-            "vwxyz",
-        ]);
-        const fox = "The quick brown fox jumped over the lazy dog";
-        expectLines(fox, 50, [fox]);
-        expectLines(fox, 40, [
-            //       1         2         3         4
-            // 34567890123456789012345678901234567890
-            "The quick brown fox jumped over the ",
-            "lazy dog",
-        ]);
-        expectLines(fox, 30, [
-            //       1         2         3
-            // 3456789012345678901234567890
-            "The quick brown fox jumped ",
-            "over the lazy dog",
-        ]);
-        expectLines(fox, 20, [
-            //       1         2
-            // 345678901234567890
-            "The quick brown fox ",
-            "jumped over the ",
-            "lazy dog",
-        ]);
-        expectLines(fox, 10, [
-            //        1
-            // 234567890
-            "The quick ",
-            "brown fox ",
-            "jumped ",
-            "over the ",
-            "lazy dog",
-        ]);
-    });
-    it("considers consecutive whitespace part of a single 'word'", function () {
-        if (!isIntlSupported()) {
-            this.skip();
-        }
-        expectLines("a b  c   d    e     f      ", 3, [
-            "a ",
-            "b  ",
-            "c   ",
-            "d    ",
-            "e     ",
-            "f      ",
-        ]);
-    });
-    it("wraps Japanese text", function () {
-        if (!isIntlSupported()) {
-            this.skip();
-        }
-        // "I am a cat. The name is Tanuki."
-        expectLines("吾輩は猫である。名前はたぬき。", 1, ["吾", "輩", "は", "猫", "で", "あ", "る。", "名", "前", "は", "た", "ぬ", "き。"]);
-    });
-    it("performs word-wrapping with punctuation", function () {
-        if (!isIntlSupported()) {
-            this.skip();
-        }
-        expectLines("1.24 56.7 8,910", 1, ["1.24 ", "56.7 ", "8,910"]);
-        expectLines("a.bc de.f g,hij", 1, ["a.bc ", "de.f ", "g,hij"]);
-        expectLines("Let's see... can you (or anyone) predict?!", 1, [
-            "Let's ",
-            "see... ",
-            "can ",
-            "you ",
-            "(or ",
-            "anyone) ",
-            "predict?!",
-        ]);
-    });
-    it("performs word-wrapping and line-splitting with multiple runs", function () {
-        if (!isIntlSupported()) {
-            this.skip();
-        }
-        const textBlock = TextBlock.create({ styleName: "" });
-        for (const str of ["The ", "quick brown", " fox jumped over ", "the lazy ", "dog"]) {
-            textBlock.appendRun(makeTextRun(str));
-        }
-        function test(width, expected) {
-            textBlock.width = width;
-            const layout = doLayout(textBlock);
-            const actual = layout.lines.map((line) => line.runs.map((runLayout) => runLayout.source.content.substring(runLayout.charOffset, runLayout.charOffset + runLayout.numChars)).join(""));
-            expect(actual).to.deep.equal(expected);
-        }
-        test(50, ["The quick brown fox jumped over the lazy dog"]);
-        test(40, [
-            //        1         2         3         4
-            // 34567890123456789012345678901234567890
-            "The quick brown fox jumped over the ",
-            "lazy dog",
-        ]);
-        test(30, [
-            //        1         2         3
-            // 3456789012345678901234567890
-            "The quick brown fox jumped ",
-            "over the lazy dog",
-        ]);
-        test(20, [
-            //        1         2
-            // 345678901234567890
-            "The quick brown fox ",
-            "jumped over the ",
-            "lazy dog",
-        ]);
-        test(10, [
-            //        1
-            // 34567890
-            "The quick ",
-            "brown fox ",
-            "jumped ",
-            "over the ",
-            "lazy dog",
-        ]);
-    });
-    it("wraps multiple runs", function () {
-        if (!isIntlSupported()) {
-            this.skip();
-        }
-        const block = TextBlock.create({ styleName: "" });
-        block.appendRun(makeTextRun("aa")); // 2 chars wide
-        block.appendRun(makeTextRun("bb ccc d ee")); // 11 chars wide
-        block.appendRun(makeTextRun("ff ggg h")); // 8 chars wide
-        function expectLayout(width, expected) {
-            block.width = width;
-            const layout = doLayout(block);
-            expect(layout.stringify()).to.equal(expected);
-        }
-        expectLayout(23, "aabb ccc d eeff ggg h");
-        expectLayout(22, "aabb ccc d eeff ggg h");
-        expectLayout(21, "aabb ccc d eeff ggg h");
-        expectLayout(20, "aabb ccc d eeff ggg \nh");
-        expectLayout(19, "aabb ccc d eeff \nggg h");
-        expectLayout(18, "aabb ccc d eeff \nggg h");
-        expectLayout(17, "aabb ccc d eeff \nggg h");
-        expectLayout(16, "aabb ccc d eeff \nggg h");
-        expectLayout(15, "aabb ccc d ee\nff ggg h");
-        expectLayout(14, "aabb ccc d ee\nff ggg h");
-        expectLayout(13, "aabb ccc d ee\nff ggg h");
-        expectLayout(12, "aabb ccc d \neeff ggg h");
-        expectLayout(11, "aabb ccc d \neeff ggg h");
-        expectLayout(10, "aabb ccc \nd eeff \nggg h");
-        expectLayout(9, "aabb ccc \nd eeff \nggg h");
-        expectLayout(8, "aabb \nccc d ee\nff ggg h");
-        expectLayout(7, "aabb \nccc d \neeff \nggg h");
-        expectLayout(6, "aabb \nccc d \neeff \nggg h");
-        expectLayout(5, "aabb \nccc \nd ee\nff \nggg h");
-        expectLayout(4, "aa\nbb \nccc \nd ee\nff \nggg \nh");
-        expectLayout(3, "aa\nbb \nccc \nd \nee\nff \nggg \nh");
-        expectLayout(2, "aa\nbb \nccc \nd \nee\nff \nggg \nh");
-        expectLayout(1, "aa\nbb \nccc \nd \nee\nff \nggg \nh");
-        expectLayout(0, "aabb ccc d eeff ggg h");
-        expectLayout(-1, "aabb ccc d eeff ggg h");
-        expectLayout(-2, "aabb ccc d eeff ggg h");
-    });
-    it("does not word wrap due to floating point rounding error", function () {
-        if (!isIntlSupported()) {
-            this.skip();
-        }
-        const block = TextBlock.create({ styleName: "", styleOverrides: { lineHeight: 1, lineSpacingFactor: 0 } });
-        block.appendRun(makeTextRun("abc defg"));
-        const layout1 = doLayout(block);
-        let width = layout1.range.xLength();
-        // Simulate a floating point rounding error by slightly reducing the width
-        width -= Geometry.smallFloatingPoint;
-        block.width = width;
-        const layout2 = doLayout(block);
-        expect(layout2.range.yLength()).to.equal(1);
-    });
-    it("has consistent data when converted to a layout result", function () {
-        if (!isIntlSupported()) {
-            this.skip();
-        }
-        // Initialize a new TextBlockLayout object
-        const textBlock = TextBlock.create({ width: 50, styleName: "", styleOverrides: { widthFactor: 34, color: 0x00ff00, fontName: "arial" } });
-        const run0 = TextRun.create({
-            content: "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus pretium mi sit amet magna malesuada, at venenatis ante eleifend.",
-            styleName: "",
-            styleOverrides: { lineHeight: 56, color: 0xff0000 },
-        });
-        const run1 = TextRun.create({
-            content: "Donec sit amet semper sapien. Nullam commodo, libero a accumsan lacinia, metus enim pharetra lacus, eu facilisis sem nisi eu dui.",
-            styleName: "",
-            styleOverrides: { widthFactor: 78, fontName: "run1" },
-        });
-        const run2 = TextRun.create({
-            content: "Duis dui quam, suscipit quis feugiat id, fermentum ut augue. Mauris iaculis odio rhoncus lorem eleifend, posuere viverra turpis elementum.",
-            styleName: "",
-            styleOverrides: {},
-        });
-        const fractionRun = FractionRun.create({ numerator: "num", denominator: "denom", styleName: "", styleOverrides: {} });
-        textBlock.appendRun(run0);
-        textBlock.appendRun(fractionRun);
-        textBlock.appendParagraph();
-        textBlock.appendRun(run1);
-        textBlock.appendRun(run2);
-        // Call the toResult() method
-        const textBlockLayout = doLayout(textBlock, {
-            findFontId: (fontName) => {
-                if (fontName === "arial") {
-                    return 1;
-                }
-                else if (fontName === "run1") {
-                    return 2;
-                }
-                return 0;
-            },
-        });
-        const result = textBlockLayout.toResult();
-        // Assert that the result object has the same data as the original TextBlockLayout object
-        expect(result.range).to.deep.equal(textBlockLayout.range.toJSON());
-        expect(result.lines.length).to.equal(textBlockLayout.lines.length);
-        // Loop through each line in the result and the original object
-        for (let i = 0; i < result.lines.length; i++) {
-            const resultLine = result.lines[i];
-            const originalLine = textBlockLayout.lines[i];
-            // Source paragraph index matches
-            expect(resultLine.sourceParagraphIndex).to.equal(textBlock.paragraphs.indexOf(originalLine.source));
-            // Ranges match
-            expect(resultLine.range).to.deep.equal(originalLine.range.toJSON());
-            expect(resultLine.justificationRange).to.deep.equal(originalLine.justificationRange.toJSON());
-            // Offset matches
-            expect(resultLine.offsetFromDocument).to.deep.equal(originalLine.offsetFromDocument);
-            for (let j = 0; j < resultLine.runs.length; j++) {
-                const resultRun = resultLine.runs[j];
-                const originalRun = originalLine.runs[j];
-                // Source run index matches
-                expect(resultRun.sourceRunIndex).to.equal(textBlock.paragraphs[resultLine.sourceParagraphIndex].runs.indexOf(originalRun.source));
-                // FontId matches
-                expect(resultRun.fontId).to.equal(originalRun.fontId);
-                // Offsets match
-                expect(resultRun.characterOffset).to.equal(originalRun.charOffset);
-                expect(resultRun.characterCount).to.equal(originalRun.numChars);
-                expect(resultRun.offsetFromLine).to.deep.equal(originalRun.offsetFromLine);
-                // Range matches
-                expect(resultRun.range).to.deep.equal(originalRun.range.toJSON());
-                // Text style matches
-                expect(resultRun.textStyle).to.deep.equal(originalRun.style.toJSON());
-                // Optional values match existence and values
-                if (resultRun.justificationRange) {
-                    expect(originalRun.justificationRange);
-                }
-                if (originalRun.justificationRange) {
-                    expect(resultRun.justificationRange);
-                }
-                if (resultRun.justificationRange && originalRun.justificationRange) {
-                    expect(resultRun.justificationRange).to.deep.equal(originalRun.justificationRange.toJSON());
-                }
-                if (resultRun.numeratorRange) {
-                    expect(originalRun.numeratorRange);
-                }
-                if (originalRun.numeratorRange) {
-                    expect(resultRun.numeratorRange);
-                }
-                if (resultRun.numeratorRange && originalRun.numeratorRange) {
-                    expect(resultRun.numeratorRange).to.deep.equal(originalRun.numeratorRange.toJSON());
-                }
-                if (resultRun.denominatorRange) {
-                    expect(originalRun.denominatorRange);
-                }
-                if (originalRun.denominatorRange) {
-                    expect(resultRun.denominatorRange);
-                }
-                if (resultRun.denominatorRange && originalRun.denominatorRange) {
-                    expect(resultRun.denominatorRange).to.deep.equal(originalRun.denominatorRange.toJSON());
-                }
-                // Check that the result string matches what we expect
-                const inputRun = textBlock.paragraphs[resultLine.sourceParagraphIndex].runs[resultRun.sourceRunIndex].clone();
-                if (inputRun.type === "text") {
-                    const resultText = inputRun.content.substring(resultRun.characterOffset, resultRun.characterOffset + resultRun.characterCount);
-                    const originalText = inputRun.content.substring(originalRun.charOffset, originalRun.charOffset + originalRun.numChars);
-                    expect(resultText).to.equal(originalText);
-                }
-            }
-        }
-    });
-    it("adds margins", function () {
-        const expectMargins = (layoutRange, marginRange, margins) => {
-            expect(marginRange.low.x).to.equal(layoutRange.low.x - (margins.left ?? 0));
-            expect(marginRange.high.x).to.equal(layoutRange.high.x + (margins.right ?? 0));
-            expect(marginRange.low.y).to.equal(layoutRange.low.y - (margins.bottom ?? 0));
-            expect(marginRange.high.y).to.equal(layoutRange.high.y + (margins.top ?? 0));
-        };
-        const makeTextBlock = (margins) => {
-            const textblock = TextBlock.create({ styleName: "", styleOverrides: { lineSpacingFactor: 0 }, margins });
-            textblock.appendRun(makeTextRun("abc"));
-            textblock.appendRun(makeTextRun("defg"));
-            return textblock;
-        };
-        let block = makeTextBlock({});
-        let layout = doLayout(block);
-        // Margins should be 0 by default
-        expect(layout.range.isAlmostEqual(layout.textRange)).to.be.true;
-        expectMargins(layout.textRange, layout.range, {});
-        // All margins should be applied to the range
-        block = makeTextBlock({ left: 1, right: 2, top: 3, bottom: 4 });
-        layout = doLayout(block);
-        expectMargins(layout.textRange, layout.range, { left: 1, right: 2, top: 3, bottom: 4 });
-        // Just horisontal margins should be applied
-        block = makeTextBlock({ left: 1, right: 2 });
-        layout = doLayout(block);
-        expectMargins(layout.textRange, layout.range, { left: 1, right: 2 });
-        // Just vertical margins should be applied
-        block = makeTextBlock({ top: 1, bottom: 2 });
-        layout = doLayout(block);
-        expectMargins(layout.textRange, layout.range, { top: 1, bottom: 2 });
-    });
-    describe("grapheme offsets", () => {
-        it("should return an empty array if source type is not text", function () {
-            const textBlock = TextBlock.create({ styleName: "" });
-            const fractionRun = FractionRun.create({ numerator: "1", denominator: "2", styleName: "fraction" });
-            textBlock.appendRun(fractionRun);
-            const layout = doLayout(textBlock);
-            const result = layout.toResult();
-            const args = {
-                textBlock,
-                iModel: {},
-                findTextStyle: () => TextStyleSettings.defaults,
-                findFontId: () => 0,
-                computeTextRange: computeTextRangeAsStringLength,
-                paragraphIndex: result.lines[0].sourceParagraphIndex,
-                runLayoutResult: result.lines[0].runs[0],
-                graphemeCharIndexes: [0],
-            };
-            const graphemeRanges = computeGraphemeOffsets(args);
-            expect(graphemeRanges).to.be.an("array").that.is.empty;
-        });
-        it("should handle empty text content", function () {
-            const textBlock = TextBlock.create({ styleName: "" });
-            const textRun = TextRun.create({ content: "", styleName: "text" });
-            textBlock.appendRun(textRun);
-            const layout = doLayout(textBlock);
-            const result = layout.toResult();
-            const args = {
-                textBlock,
-                iModel: {},
-                findTextStyle: () => TextStyleSettings.defaults,
-                findFontId: () => 0,
-                computeTextRange: computeTextRangeAsStringLength,
-                paragraphIndex: result.lines[0].sourceParagraphIndex,
-                runLayoutResult: result.lines[0].runs[0],
-                graphemeCharIndexes: [0], // Supply a grapheme index even though there is no text
-            };
-            const graphemeRanges = computeGraphemeOffsets(args);
-            expect(graphemeRanges).to.be.an("array").that.is.empty;
-        });
-        it("should compute grapheme offsets correctly for a given text", function () {
-            const textBlock = TextBlock.create({ styleName: "" });
-            const textRun = TextRun.create({ content: "hello", styleName: "text" });
-            textBlock.appendRun(textRun);
-            const layout = doLayout(textBlock);
-            const result = layout.toResult();
-            const args = {
-                textBlock,
-                iModel: {},
-                findTextStyle: () => TextStyleSettings.defaults,
-                findFontId: () => 0,
-                computeTextRange: computeTextRangeAsStringLength,
-                paragraphIndex: result.lines[0].sourceParagraphIndex,
-                runLayoutResult: result.lines[0].runs[0],
-                graphemeCharIndexes: [0, 1, 2, 3, 4],
-            };
-            const graphemeRanges = computeGraphemeOffsets(args);
-            expect(graphemeRanges).to.be.an("array").that.has.lengthOf(5);
-            expect(graphemeRanges[0].high.x).to.equal(1);
-            expect(graphemeRanges[4].high.x).to.equal(5);
-        });
-        it("should compute grapheme offsets correctly for non-English text", function () {
-            const textBlock = TextBlock.create({ styleName: "" });
-            // Hindi - "Paragraph"
-            const textRun = TextRun.create({ content: "अनुच्छेद", styleName: "text" });
-            textBlock.appendRun(textRun);
-            const layout = doLayout(textBlock);
-            const result = layout.toResult();
-            const args = {
-                textBlock,
-                iModel: {},
-                findTextStyle: () => TextStyleSettings.defaults,
-                findFontId: () => 0,
-                computeTextRange: computeTextRangeAsStringLength,
-                paragraphIndex: result.lines[0].sourceParagraphIndex,
-                runLayoutResult: result.lines[0].runs[0],
-                graphemeCharIndexes: [0, 1, 3, 7],
-            };
-            const graphemeRanges = computeGraphemeOffsets(args);
-            expect(graphemeRanges).to.be.an("array").that.has.lengthOf(4); // Length based on actual grapheme segmentation
-            expect(graphemeRanges[0].high.x).to.equal(1);
-            expect(graphemeRanges[1].high.x).to.equal(3);
-            expect(graphemeRanges[2].high.x).to.equal(7);
-            expect(graphemeRanges[3].high.x).to.equal(8);
-        });
-        it("should compute grapheme offsets correctly for emoji content", function () {
-            const textBlock = TextBlock.create({ styleName: "" });
-            const textRun = TextRun.create({ content: "👨‍👦", styleName: "text" });
-            textBlock.appendRun(textRun);
-            const layout = doLayout(textBlock);
-            const result = layout.toResult();
-            const args = {
-                textBlock,
-                iModel: {},
-                findTextStyle: () => TextStyleSettings.defaults,
-                findFontId: () => 0,
-                computeTextRange: computeTextRangeAsStringLength,
-                paragraphIndex: result.lines[0].sourceParagraphIndex,
-                runLayoutResult: result.lines[0].runs[0],
-                graphemeCharIndexes: [0],
-            };
-            const graphemeRanges = computeGraphemeOffsets(args);
-            expect(graphemeRanges).to.be.an("array").that.has.lengthOf(1); // Length based on actual grapheme segmentation
-            expect(graphemeRanges[0].high.x).to.equal(5);
-        });
-    });
-    describe("using native font library", () => {
-        let iModel;
-        before(() => {
-            const seedFileName = IModelTestUtils.resolveAssetFile("CompatibilityTestSeed.bim");
-            const testFileName = IModelTestUtils.prepareOutputFile("NativeFonts", "NativeFonts.bim");
-            iModel = IModelTestUtils.createSnapshotFromSeed(testFileName, seedFileName);
-        });
-        after(() => iModel.close());
-        it("maps font names to Id", async () => {
-            const vera = iModel.fonts.findId({ name: "Vera" });
-            expect(vera).to.equal(1);
-            const arial = await iModel.fonts.acquireId({ name: "Arial", type: FontType.TrueType });
-            const comic = await iModel.fonts.acquireId({ name: "Comic Sans", type: FontType.TrueType });
-            iModel.saveChanges();
-            expect(arial).to.equal(2);
-            expect(comic).to.equal(3);
-            expect(iModel.fonts.findId({ name: "Consolas" })).to.be.undefined;
-            function test(fontName, expectedFontId) {
-                const textBlock = TextBlock.create({ styleName: "" });
-                textBlock.appendRun(TextRun.create({ styleName: "", styleOverrides: { fontName } }));
-                const layout = layoutTextBlock({ textBlock, iModel });
-                const run = layout.lines[0].runs[0];
-                expect(run).not.to.be.undefined;
-                expect(run.fontId).to.equal(expectedFontId);
-            }
-            test("Arial", arial);
-            test("Comic Sans", comic);
-            test("Consolas", 0);
-            test("arial", arial);
-            test("aRIaL", arial);
-        });
-        function computeDimensions(args) {
-            const textBlock = TextBlock.create({
-                styleName: "",
-                styleOverrides: {
-                    lineHeight: args.height,
-                    widthFactor: args.width,
-                },
-            });
-            textBlock.appendRun(TextRun.create({
-                styleName: "",
-                content: args.content ?? "This is a string of text.",
-                styleOverrides: {
-                    isBold: args.bold,
-                    isItalic: args.italic,
-                    fontName: args.font ?? "Vera",
-                },
-            }));
-            const range = layoutTextBlock({ textBlock, iModel }).range;
-            return { x: range.high.x - range.low.x, y: range.high.y - range.low.y };
-        }
-        it("computes different ranges for different strings", () => {
-            expect(computeDimensions({ content: "text" })).to.deep.equal(computeDimensions({ content: "text" }));
-            expect(computeDimensions({ content: "text" })).not.to.deep.equal(computeDimensions({ content: "texttexttext" }));
-            expect(computeDimensions({ content: "text" })).not.to.deep.equal(computeDimensions({ content: "TEXT" }));
-        });
-        it("computes different ranges for different fonts", () => {
-            // These two are embedded in the iModel.
-            expect(computeDimensions({ font: "Vera" })).not.to.deep.equal(computeDimensions({ font: "Karla" }));
-            // These two are not embedded in the iModel, but do exist in its font table - they should both fall back to the default font.
-            expect(computeDimensions({ font: "Arial" })).to.deep.equal(computeDimensions({ font: "Comic Sans" }));
-        });
-        it("computes different ranges for different height and width", () => {
-            expect(computeDimensions({ height: 2 })).to.deep.equal(computeDimensions({ height: 2 }));
-            expect(computeDimensions({ height: 2 })).not.to.deep.equal(computeDimensions({ height: 3 }));
-            expect(computeDimensions({ width: 2 })).to.deep.equal(computeDimensions({ width: 2 }));
-            expect(computeDimensions({ width: 2 })).not.to.deep.equal(computeDimensions({ width: 3 }));
-            expect(computeDimensions({ height: 2 }).y).to.equal(2);
-            expect(computeDimensions({ height: 3 }).y).to.equal(3);
-            const dims = computeDimensions({ height: 2 });
-            expect(computeDimensions({ height: 2, width: 1 })).to.deep.equal(dims);
-            expect(computeDimensions({ height: 2, width: 0.5 })).to.deep.equal({ x: 0.5 * dims.x, y: dims.y });
-            expect(computeDimensions({ height: 2, width: 2 })).to.deep.equal({ x: 2 * dims.x, y: dims.y });
-        });
-        it("excludes trailing blank glyphs from justification ranges", () => {
-            function computeRanges(chars) {
-                return iModel.computeRangesForText({
-                    chars,
-                    bold: false,
-                    italic: false,
-                    fontId: 1,
-                    widthFactor: 1,
-                    lineHeight: 1,
-                    baselineShift: "none",
-                });
-            }
-            function test(chars, expectEqualRanges) {
-                const { justification, layout } = computeRanges(chars);
-                expect(layout.low.x).to.equal(justification.low.x);
-                expect(layout.high.y).to.equal(justification.high.y);
-                expect(layout.low.y).to.equal(justification.low.y);
-                if (expectEqualRanges) {
-                    expect(layout.high.x).to.equal(justification.high.x);
-                }
-                else {
-                    expect(layout.high.x).greaterThan(justification.high.x);
-                }
-            }
-            test("abcdef", true);
-            test("abcdef ", false);
-            test("abcdef   ", false);
-            test("abc def", true);
-            // new line has no width ever.
-            test("abcdef\n", true);
-            // apparently native code doesn't consider tab characters to be "blank".
-            test("abcdef\t", true);
-            // apparently native code doesn't consider "thin space" to be "blank".
-            test("abcdef\u2009", true);
-            const r1 = computeRanges("abcdef ");
-            const r2 = computeRanges("abcdef    ");
-            expect(r1.layout.xLength()).lessThan(r2.layout.xLength());
-            expect(r1.justification.xLength()).to.equal(r2.justification.xLength());
-        });
-    });
-});
 function mockIModel() {
     const iModel = {
         fonts: {
             findId: () => 0,
         },
-        computeRangesForText: () => { return { layout: new Range2d(0, 0, 1, 1), justification: new Range2d(0, 0, 1, 1) }; },
+        computeRangesForText: computeTextRangeAsStringLength,
         forEachMetaData: () => undefined,
     };
     return iModel;
 }
-describe("produceTextAnnotationGeometry", () => {
-    function makeText(color) {
-        const styleOverrides = undefined !== color ? { color: color instanceof ColorDef ? color.toJSON() : color } : undefined;
-        return TextRun.create({ styleName: "", styleOverrides, content: "text" });
-    }
-    function makeFraction(color) {
-        const styleOverrides = undefined !== color ? { color: color instanceof ColorDef ? color.toJSON() : color } : undefined;
-        return FractionRun.create({ numerator: "num", denominator: "denom", styleName: "", styleOverrides });
-    }
-    function makeBreak(color) {
-        const styleOverrides = undefined !== color ? { color: color instanceof ColorDef ? color.toJSON() : color } : undefined;
-        return LineBreakRun.create({ styleName: "", styleOverrides });
-    }
-    function makeTextBlock(runs) {
-        const block = TextBlock.create({ styleName: "" });
-        for (const run of runs) {
-            block.appendRun(run);
-        }
-        return block;
-    }
-    function makeGeometry(runs) {
-        const block = makeTextBlock(runs);
-        const annotation = TextAnnotation.fromJSON({ textBlock: block.toJSON() });
-        return produceTextAnnotationGeometry({ iModel: mockIModel(), annotation }).entries;
-    }
-    it("produces an empty array for an empty text block", () => {
-        expect(makeGeometry([])).to.deep.equal([]);
-    });
-    it("produces an empty array for a block consisting only of line breaks", () => {
-        expect(makeGeometry([makeBreak(), makeBreak(), makeBreak()])).to.deep.equal([]);
-    });
-    it("produces one appearance entry if all runs use subcategory color", () => {
-        const geom = makeGeometry([makeText(), makeFraction(), makeText("subcategory"), makeFraction("subcategory")]);
-        expect(geom.length).to.equal(9);
-        expect(geom[0].color).to.equal("subcategory");
-        expect(geom.slice(1).some((entry) => entry.color !== undefined)).to.be.false;
-    });
-    it("produces strings and fraction separators", () => {
-        const geom = makeGeometry([makeText(), makeFraction(), makeFraction(), makeText()]);
-        expect(geom.length).to.equal(9);
-        expect(geom[0].color).to.equal("subcategory");
-        expect(geom[1].text).not.to.be.undefined;
-        expect(geom[2].text).not.to.be.undefined;
-        expect(geom[3].separator).not.to.be.undefined;
-        expect(geom[4].text).not.to.be.undefined;
-        expect(geom[5].text).not.to.be.undefined;
-        expect(geom[6].separator).not.to.be.undefined;
-        expect(geom[7].text).not.to.be.undefined;
-        expect(geom[8].text).not.to.be.undefined;
-    });
-    it("produces an appearance change for each non-break run that is a different color from the previous run", () => {
-        const geom = makeGeometry([
-            makeText(ColorDef.blue),
-            makeText(), // subcategory by default
-            makeText(),
-            makeText(ColorDef.red),
-            makeText(ColorDef.white),
-            makeText(ColorDef.white),
-            makeBreak("subcategory"),
-            makeFraction(ColorDef.green),
-            makeText(ColorDef.green),
-            makeBreak(ColorDef.black),
-            makeText(ColorDef.green),
-        ]).map((entry) => entry.text ? "text" : (entry.separator ? "sep" : (typeof entry.color === "number" ? ColorDef.fromJSON(entry.color) : entry.color)));
-        expect(geom).to.deep.equal([
-            ColorDef.blue,
-            "text",
-            "subcategory",
-            "text",
-            "text",
-            ColorDef.red,
-            "text",
-            ColorDef.white,
-            "text",
-            "text",
-            ColorDef.green,
-            "text", "sep", "text",
-            "text",
-            "text",
-        ]);
-    });
-    it("offsets geometry entries by margins", () => {
-        function makeGeometryWithMargins(anchor, margins) {
-            const runs = [makeText()];
-            const block = makeTextBlock(runs);
-            block.margins = margins;
-            const annotation = TextAnnotation.fromJSON({ textBlock: block.toJSON() });
-            annotation.anchor = anchor;
-            const geom = produceTextAnnotationGeometry({ iModel: mockIModel(), annotation }).entries;
-            return geom[1].text;
-        }
-        function testMargins(margins, height, width) {
-            // We want to disregard negative margins. Note, I'm not changing the margins object itself. It gets passed into makeGeometryWithMargins as it is.
-            const left = margins.left >= 0 ? margins.left : 0;
-            const right = margins.right >= 0 ? margins.right : 0;
-            const top = margins.top >= 0 ? margins.top : 0;
-            const bottom = margins.bottom >= 0 ? margins.bottom : 0;
-            // Test case: bottom, left
-            let props = makeGeometryWithMargins({ horizontal: "left", vertical: "bottom" }, margins);
-            expect(props).not.to.be.undefined;
-            expect(props?.origin, "Expected geometry to be offset by left and bottom margins").to.deep.equal({ x: left, y: bottom, z: 0 });
-            // Test case: top, right
-            props = makeGeometryWithMargins({ vertical: "top", horizontal: "right" }, margins);
-            let x = (right + width) * -1;
-            let y = (top + height) * -1;
-            expect(props).not.to.be.undefined;
-            expect(props?.origin, "Expected geometry to be offset by top and right margins").to.deep.equal({ x, y, z: 0 });
-            // Test case: middle, center
-            props = makeGeometryWithMargins({ vertical: "middle", horizontal: "center" }, margins);
-            x = (left - right - width) / 2;
-            y = (bottom - top - height) / 2;
-            expect(props).not.to.be.undefined;
-            expect(props?.origin, "Expected geometry to be centered in the margins").to.deep.equal({ x, y, z: 0 });
-        }
-        // Getting the range from the same mock the native code uses to compute the range of a text block.
-        const textRange = mockIModel().computeRangesForText({
-            chars: "text",
-            bold: false,
-            italic: false,
-            fontId: 1,
-            widthFactor: 1,
-            lineHeight: 1,
-            baselineShift: "none",
-        });
-        const xLength = textRange.layout.xLength(); // Will be 1 because of the mock implementation.
-        const yLength = textRange.layout.yLength(); // Will be 1 because of the mock implementation.
-        testMargins({ top: 0, right: 0, bottom: 0, left: 0 }, yLength, xLength);
-        testMargins({ top: 1, right: 2, bottom: 3, left: 4 }, yLength, xLength);
-        testMargins({ top: -1, right: -2, bottom: -3, left: -4 }, yLength, xLength);
-    });
-});
 describe("TextAnnotation element", () => {
     function makeElement(props) {
         return TextAnnotation2d.fromJSON({
@@ -999,6 +39,10 @@ describe("TextAnnotation element", () => {
                 scope: "0x78",
             },
             classFullName: TextAnnotation2d.classFullName,
+            placement: {
+                origin: { x: 0, y: 0 },
+                angle: 0,
+            },
             ...props,
         }, mockIModel());
     }
@@ -1034,74 +78,117 @@ describe("TextAnnotation element", () => {
         });
     });
     describe("setAnnotation", () => {
-        it("updates JSON properties and recomputes geometry stream", () => {
+        it("updates JSON properties", () => {
             const elem = makeElement();
-            expect(elem.geom).to.be.undefined;
-            const annotation = { textBlock: TextBlock.create({ styleName: "block" }).toJSON() };
-            elem.setAnnotation(TextAnnotation.fromJSON(annotation));
-            expect(elem.geom).not.to.be.undefined;
-            expect(elem.jsonProperties.annotation).to.deep.equal(annotation);
-            expect(elem.jsonProperties.annotation).not.to.equal(annotation);
+            const textBlock = TextBlock.create({ styleName: "block" });
+            textBlock.appendRun(TextRun.create({ content: "text", styleName: "run" }));
+            const annotation = TextAnnotation.fromJSON({ textBlock: textBlock.toJSON() });
+            elem.setAnnotation(annotation);
+            expect(elem.jsonProperties.annotation).to.deep.equal(annotation.toJSON());
+            expect(elem.jsonProperties.annotation).not.to.equal(annotation.toJSON());
         });
-        it("uses default subcategory by default", () => {
-            const elem = makeElement();
-            elem.setAnnotation(TextAnnotation.fromJSON({ textBlock: { styleName: "block" } }));
-            expect(elem.geom.length).to.equal(1);
-            expect(elem.geom[0].appearance.subCategory).to.equal("0x13");
+        // it("uses default subcategory by default", () => {
+        //   const elem = makeElement();
+        //   elem.setAnnotation(TextAnnotation.fromJSON({ textBlock: { styleName: "block" } }));
+        //   expect(elem.geom!.length).to.equal(1);
+        //   expect(elem.geom![0].appearance!.subCategory).to.equal("0x13");
+        // });
+        // it("uses specific subcategory if provided", () => {
+        //   const elem = makeElement();
+        //   elem.setAnnotation(TextAnnotation.fromJSON({ textBlock: { styleName: "block" } }));
+        //   expect(elem.geom!.length).to.equal(1);
+        //   expect(elem.geom![0].appearance!.subCategory).to.equal("0x1234");
+        // });
+    });
+    function createAnnotation() {
+        const styleOverrides = { fontName: "Karla" };
+        const block = TextBlock.create({ styleName: "block", styleOverrides });
+        block.appendRun(TextRun.create({ content: "Run, Barry,", styleName: "run1", styleOverrides }));
+        block.appendRun(TextRun.create({ content: " RUN!!! ", styleName: "run2", styleOverrides }));
+        block.appendRun(FractionRun.create({ numerator: "Harrison", denominator: "Wells", styleName: "run3", styleOverrides }));
+        block.margins = { left: 0, right: 1, top: 2, bottom: 3 };
+        const annotation = TextAnnotation.fromJSON({ textBlock: block.toJSON() });
+        annotation.anchor = { vertical: "middle", horizontal: "right" };
+        annotation.orientation = YawPitchRollAngles.createDegrees(1, 0, -1);
+        annotation.offset = Point3d.create(10, -5, 0);
+        annotation.frame = { shape: "rectangle", border: ColorDef.red.toJSON(), fill: ColorDef.green.toJSON(), borderWeight: 2 };
+        return annotation;
+    }
+    const createJobSubjectElement = (iModel, name) => {
+        const subj = Subject.create(iModel, iModel.elements.getRootSubject().id, name);
+        subj.setJsonProperty("Subject", { Job: name }); // eslint-disable-line @typescript-eslint/naming-convention
+        return subj;
+    };
+    const insertDrawingModel = (standaloneModel, parentId) => {
+        const definitionModel = DefinitionModel.insert(standaloneModel, parentId, "DrawingDefinition");
+        const category = DrawingCategory.insert(standaloneModel, definitionModel, "DrawingCategory", new SubCategoryAppearance());
+        const [_, model] = IModelTestUtils.createAndInsertDrawingPartitionAndModel(standaloneModel, { spec: '0x1', scope: '0x1', value: 'Drawing' }, undefined, parentId);
+        const displayStyle = DisplayStyle2d.insert(standaloneModel, definitionModel, "DisplayStyle2d");
+        const categorySelector = CategorySelector.insert(standaloneModel, definitionModel, "DrawingCategories", [category]);
+        const viewRange = new Range2d(0, 0, 500, 500);
+        DrawingViewDefinition.insert(standaloneModel, definitionModel, "Drawing View", model, categorySelector, displayStyle, viewRange);
+        return { category, model };
+    };
+    const insertSpatialModel = (standaloneModel, parentId) => {
+        const definitionModel = DefinitionModel.insert(standaloneModel, parentId, "SpatialDefinition");
+        const category = SpatialCategory.insert(standaloneModel, definitionModel, "spatialCategory", new SubCategoryAppearance());
+        const [_, model] = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(standaloneModel, { spec: '0x1', scope: '0x1', value: 'Spatial' }, undefined, parentId);
+        const modelSelector = ModelSelector.insert(standaloneModel, definitionModel, "SpatialModelSelector", [model]);
+        const displayStyle = DisplayStyle3d.insert(standaloneModel, definitionModel, "DisplayStyle3d");
+        const categorySelector = CategorySelector.insert(standaloneModel, definitionModel, "spatialCategories", [category]);
+        const viewRange = new Range3d(0, 0, 0, 500, 500, 500);
+        SpatialViewDefinition.insertWithCamera(standaloneModel, definitionModel, "spatial View", modelSelector, categorySelector, displayStyle, viewRange);
+        return { category, model };
+    };
+    const createIModel = async (name) => {
+        const filePath = IModelTestUtils.prepareOutputFile("annotationTests", `${name}.bim`);
+        const iModel = StandaloneDb.createEmpty(filePath, {
+            rootSubject: { name: `${name} tests`, description: `${name} tests` },
+            client: "integration tests",
+            globalOrigin: { x: 0, y: 0 },
+            projectExtents: { low: { x: -500, y: -500, z: -50 }, high: { x: 500, y: 500, z: 50 } },
+            guid: Guid.createValue(),
         });
-        it("uses specific subcategory if provided", () => {
-            const elem = makeElement();
-            elem.setAnnotation(TextAnnotation.fromJSON({ textBlock: { styleName: "block" } }), "0x1234");
-            expect(elem.geom.length).to.equal(1);
-            expect(elem.geom[0].appearance.subCategory).to.equal("0x1234");
+        await iModel.fonts.embedFontFile({
+            file: FontFile.createFromTrueTypeFileName(IModelTestUtils.resolveFontFile("Karla-Regular.ttf"))
         });
-    });
-    describe("persistence", () => {
+        return iModel;
+    };
+    describe("TextAnnotation3d Persistence", () => {
         let imodel;
-        let seed;
-        before(() => {
-            const seedFileName = IModelTestUtils.resolveAssetFile("CompatibilityTestSeed.bim");
-            const testFileName = IModelTestUtils.prepareOutputFile("GeometryStream", "GeometryStreamTest.bim");
-            imodel = IModelTestUtils.createSnapshotFromSeed(testFileName, seedFileName);
-            seed = imodel.elements.getElement("0x1d");
-            assert.exists(seed);
-            assert.isTrue(seed.federationGuid === "18eb4650-b074-414f-b961-d9cfaa6c8746");
+        let seedCategoryId;
+        let seedModelId;
+        before(async () => {
+            imodel = await createIModel("TextAnnotation3d");
+            const jobSubjectId = createJobSubjectElement(imodel, "Job").insert();
+            const { category, model } = insertSpatialModel(imodel, jobSubjectId);
+            expect(jobSubjectId).not.to.be.undefined;
+            expect(category).not.to.be.undefined;
+            expect(model).not.to.be.undefined;
+            seedCategoryId = category;
+            seedModelId = model;
         });
         after(() => imodel.close());
-        function createElement(props) {
+        function createElement3d(props) {
             return TextAnnotation3d.fromJSON({
-                category: seed.category,
-                model: seed.model,
-                code: {
-                    spec: seed.code.spec,
-                    scope: seed.code.scope,
+                category: seedCategoryId,
+                model: seedModelId,
+                code: Code.createEmpty(),
+                placement: {
+                    origin: { x: 0, y: 0, z: 0 },
+                    angles: YawPitchRollAngles.createDegrees(0, 0, 0).toJSON(),
                 },
                 ...props,
                 classFullName: TextAnnotation3d.classFullName,
             }, imodel);
         }
-        function createAnnotation() {
-            const block = TextBlock.createEmpty();
-            block.styleName = "block";
-            block.appendRun(makeTextRun("run", "run1"));
-            block.appendRun(makeTextRun("RUN!!!!!", "run2"));
-            return TextAnnotation.fromJSON({
-                textBlock: block.toJSON(),
-                anchor: {
-                    vertical: "middle",
-                    horizontal: "right",
-                },
-                orientation: { yaw: 1, pitch: 0, roll: -1 },
-                offset: [0, -5, 100],
-            });
-        }
         it("create method does not automatically compute the geometry", () => {
             const annotation = createAnnotation();
-            const el = createElement({ jsonProperties: { annotation: annotation.toJSON() } });
+            const el = createElement3d({ jsonProperties: { annotation: annotation.toJSON() } });
             expect(el.getAnnotation().equals(annotation)).to.be.true;
             expect(el.geom).to.be.undefined;
         });
-        function expectPlacement(el, expectValidBBox, expectedOrigin = [0, 0, 0], expectedYPR = [0, 0, 0]) {
+        function expectPlacement3d(el, expectValidBBox, expectedOrigin = [0, 0, 0], expectedYPR = [0, 0, 0]) {
             expect(el.placement.origin.x).to.equal(expectedOrigin[0]);
             expect(el.placement.origin.y).to.equal(expectedOrigin[1]);
             expect(el.placement.origin.z).to.equal(expectedOrigin[2]);
@@ -1110,19 +197,91 @@ describe("TextAnnotation element", () => {
             expect(el.placement.angles.roll.radians).to.equal(expectedYPR[2]);
             expect(el.placement.bbox.isNull).to.equal(!expectValidBBox);
         }
-        it("inserts and round-trips through JSON", () => {
-            function test(annotation) {
-                const el0 = createElement();
+        describe("inserts 3d element and round-trips through JSON", async () => {
+            async function test(annotation) {
+                const el0 = createElement3d();
                 if (annotation) {
                     el0.setAnnotation(annotation);
                 }
-                expectPlacement(el0, false);
+                expectPlacement3d(el0, false);
+                expect(el0.toJSON().elementGeometryBuilderParams).not.to.be.undefined;
                 const elId = el0.insert();
                 expect(Id64.isValidId64(elId)).to.be.true;
                 const el1 = imodel.elements.getElement(elId);
                 expect(el1).not.to.be.undefined;
                 expect(el1 instanceof TextAnnotation3d).to.be.true;
-                expectPlacement(el1, undefined !== annotation && !annotation.textBlock.isEmpty);
+                expectPlacement3d(el1, undefined !== annotation && !annotation.textBlock.isEmpty);
+                const anno = el1.getAnnotation();
+                if (!annotation) {
+                    expect(anno).to.be.undefined;
+                }
+                else {
+                    expect(anno).not.to.be.undefined;
+                    expect(anno.equals(annotation)).to.be.true;
+                }
+            }
+            it("roundtrips an empty annotation", async () => { await test(); });
+            it("roundtrips an annotation with a style", async () => { await test(TextAnnotation.fromJSON({ textBlock: { styleName: "block" } })); });
+            it("roundtrips an annotation with a textBlock", async () => { await test(createAnnotation()); });
+        });
+    });
+    describe("TextAnnotation2d Persistence", () => {
+        let imodel;
+        let seedCategoryId;
+        let seedModelId;
+        before(async () => {
+            imodel = await createIModel("TextAnnotation2d");
+            const jobSubjectId = createJobSubjectElement(imodel, "Job").insert();
+            const { category, model } = insertDrawingModel(imodel, jobSubjectId);
+            expect(jobSubjectId).not.to.be.undefined;
+            expect(category).not.to.be.undefined;
+            expect(model).not.to.be.undefined;
+            seedCategoryId = category;
+            seedModelId = model;
+        });
+        after(() => {
+            imodel.saveChanges("tests");
+            imodel.close();
+        });
+        function createElement2d(props) {
+            return TextAnnotation2d.fromJSON({
+                category: seedCategoryId,
+                model: seedModelId,
+                code: Code.createEmpty(),
+                placement: {
+                    origin: { x: 0, y: 0 },
+                    angle: Angle.createDegrees(0).toJSON(),
+                },
+                ...props,
+                classFullName: TextAnnotation2d.classFullName,
+            }, imodel);
+        }
+        it("create method does not automatically compute the geometry", () => {
+            const annotation = createAnnotation();
+            const el = createElement2d({ jsonProperties: { annotation: annotation.toJSON() } });
+            expect(el.getAnnotation().equals(annotation)).to.be.true;
+            expect(el.geom).to.be.undefined;
+        });
+        function expectPlacement2d(el, expectValidBBox, expectedOrigin = [0, 0, 0], expectedYPR = [0, 0, 0]) {
+            expect(el.placement.origin.x).to.equal(expectedOrigin[0]);
+            expect(el.placement.origin.y).to.equal(expectedOrigin[1]);
+            expect(el.placement.angle.degrees).to.equal(expectedYPR[0]);
+            expect(el.placement.bbox.isNull).to.equal(!expectValidBBox);
+        }
+        describe("inserts 2d element and round-trips through JSON", async () => {
+            async function test(annotation) {
+                const el0 = createElement2d();
+                if (annotation) {
+                    el0.setAnnotation(annotation);
+                }
+                expectPlacement2d(el0, false);
+                expect(el0.toJSON().elementGeometryBuilderParams).not.to.be.undefined;
+                const elId = el0.insert();
+                expect(Id64.isValidId64(elId)).to.be.true;
+                const el1 = imodel.elements.getElement(elId);
+                expect(el1).not.to.be.undefined;
+                expect(el1 instanceof TextAnnotation2d).to.be.true;
+                expectPlacement2d(el1, undefined !== annotation && !annotation.textBlock.isEmpty);
                 const anno = el1.getAnnotation();
                 if (!annotation) {
                     expect(anno).to.be.undefined;
@@ -1132,9 +291,9 @@ describe("TextAnnotation element", () => {
                     expect(anno.equals(annotation)).to.be.true;
                 }
             }
-            test();
-            test(TextAnnotation.fromJSON({ textBlock: { styleName: "block" } }));
-            test(createAnnotation());
+            it("roundtrips an empty annotation", async () => { await test(); });
+            it("roundtrips an annotation with a style", async () => { await test(TextAnnotation.fromJSON({ textBlock: { styleName: "block" } })); });
+            it("roundtrips an annotation with a textBlock", async () => { await test(createAnnotation()); });
         });
     });
 });