@itwin/core-backend 5.2.0-dev.7 → 5.3.0-dev.1

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

@@ -15,7 +15,10 @@ import { DrawingCategory, SpatialCategory } from "../../Category";
 import { DisplayStyle2d, DisplayStyle3d } from "../../DisplayStyle";
 import { CategorySelector, DrawingViewDefinition, ModelSelector, SpatialViewDefinition } from "../../ViewDefinition";
 import { FontFile } from "../../FontFile";
-import { computeTextRangeAsStringLength } from "../AnnotationTestUtils";
+import { computeTextRangeAsStringLength, MockBuilder } from "../AnnotationTestUtils";
+import { TextAnnotationUsesTextStyleByDefault } from "../../annotations/ElementDrivesTextAnnotation";
+import { layoutTextBlock, TextStyleResolver } from "../../annotations/TextBlockLayout";
+import { appendTextAnnotationGeometry } from "../../annotations/TextAnnotationGeometry";
 function mockIModel() {
     const iModel = {
         fonts: {
@@ -26,13 +29,15 @@ function mockIModel() {
     };
     return iModel;
 }
-function createAnnotation(styleId) {
+function createAnnotation(textBlock) {
     const styleOverrides = { fontName: "Karla" };
-    const block = TextBlock.create({ styleId: styleId ?? "0x42", styleOverrides });
-    block.appendRun(TextRun.create({ content: "Run, Barry,", styleOverrides }));
-    block.appendRun(TextRun.create({ content: " RUN!!! ", styleOverrides }));
-    block.appendRun(FractionRun.create({ numerator: "Harrison", denominator: "Wells", styleOverrides }));
-    block.margins = { left: 0, right: 1, top: 2, bottom: 3 };
+    const block = textBlock ?? TextBlock.create({ styleOverrides });
+    if (!textBlock) {
+        block.appendRun(TextRun.create({ content: "Run, Barry,", styleOverrides }));
+        block.appendRun(TextRun.create({ content: " RUN!!! ", styleOverrides }));
+        block.appendRun(FractionRun.create({ numerator: "Harrison", denominator: "Wells", 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);
@@ -81,6 +86,26 @@ const createIModel = async (name) => {
 const createAnnotationTextStyle = (iModel, definitionModel, name, settings = TextStyleSettings.defaultProps) => {
     return AnnotationTextStyle.create(iModel, definitionModel, name, settings, "description");
 };
+function createElement2d(imodel, createArgs) {
+    const placement = {
+        origin: { x: 0, y: 0 },
+        angle: Angle.createDegrees(0).toJSON(),
+    };
+    return TextAnnotation2d.create(imodel, {
+        ...createArgs,
+        placement,
+    });
+}
+function createElement3d(imodel, createArgs) {
+    const placement = {
+        origin: { x: 0, y: 0, z: 0 },
+        angles: YawPitchRollAngles.createDegrees(0, 0, 0).toJSON(),
+    };
+    return TextAnnotation3d.create(imodel, {
+        ...createArgs,
+        placement,
+    });
+}
 describe("TextAnnotation element", () => {
     function makeElement(props) {
         return TextAnnotation2d.fromJSON({
@@ -95,6 +120,7 @@ describe("TextAnnotation element", () => {
                 origin: { x: 0, y: 0 },
                 angle: 0,
             },
+            defaultTextStyle: new TextAnnotationUsesTextStyleByDefault("0x21").toJSON(),
             ...props,
         }, mockIModel());
     }
@@ -104,16 +130,18 @@ describe("TextAnnotation element", () => {
         });
         it("converts JSON string to class instance", () => {
             const elem = makeElement({
-                textAnnotationData: JSON.stringify({ textBlock: TextBlock.create({ styleId: "0x42" }).toJSON() })
+                textAnnotationData: JSON.stringify({ textBlock: TextBlock.create().toJSON() }),
+                defaultTextStyle: new TextAnnotationUsesTextStyleByDefault("0x42").toJSON()
             });
             const anno = elem.getAnnotation();
             expect(anno).not.to.be.undefined;
             expect(anno.textBlock.isEmpty).to.be.true;
-            expect(anno.textBlock.styleId).to.equal("0x42");
+            expect(elem.defaultTextStyle).not.to.be.undefined;
+            expect(elem.defaultTextStyle.id).to.equal("0x42");
         });
         it("produces a new object each time it is called", () => {
             const elem = makeElement({
-                textAnnotationData: JSON.stringify({ textBlock: TextBlock.create({ styleId: "0x42" }).toJSON() })
+                textAnnotationData: JSON.stringify({ textBlock: TextBlock.create().toJSON() })
             });
             const anno1 = elem.getAnnotation();
             const anno2 = elem.getAnnotation();
@@ -124,7 +152,7 @@ describe("TextAnnotation element", () => {
     describe("setAnnotation", () => {
         it("updates properties", () => {
             const elem = makeElement();
-            const textBlock = TextBlock.create({ styleId: "0x42" });
+            const textBlock = TextBlock.create();
             textBlock.appendRun(TextRun.create({ content: "text" }));
             const annotation = TextAnnotation.fromJSON({ textBlock: textBlock.toJSON() });
             elem.setAnnotation(annotation);
@@ -134,9 +162,7 @@ describe("TextAnnotation element", () => {
     });
     describe("TextAnnotation3d Persistence", () => {
         let imodel;
-        let seedCategoryId;
-        let seedModelId;
-        let seedStyleId;
+        let createElement3dArgs;
         before(async () => {
             imodel = await createIModel("TextAnnotation3d");
             const jobSubjectId = createJobSubjectElement(imodel, "Job").insert();
@@ -147,20 +173,13 @@ describe("TextAnnotation element", () => {
             expect(category).not.to.be.undefined;
             expect(model).not.to.be.undefined;
             expect(styleId).not.to.be.undefined;
-            seedCategoryId = category;
-            seedModelId = model;
-            seedStyleId = styleId;
+            createElement3dArgs = { category, model };
         });
         after(() => imodel.close());
-        function createElement3d(createArgs) {
-            return TextAnnotation3d.create(imodel, seedCategoryId, seedModelId, {
-                origin: { x: 0, y: 0, z: 0 },
-                angles: YawPitchRollAngles.createDegrees(0, 0, 0).toJSON(),
-            }, createArgs?.textAnnotationData);
-        }
         it("creating element does not automatically compute the geometry", () => {
             const annotation = createAnnotation();
-            const el = createElement3d({ textAnnotationData: annotation.toJSON() });
+            const args = { ...createElement3dArgs, textAnnotationData: annotation.toJSON() };
+            const el = createElement3d(imodel, args);
             expect(el.getAnnotation().equals(annotation)).to.be.true;
             expect(el.geom).to.be.undefined;
         });
@@ -175,7 +194,7 @@ describe("TextAnnotation element", () => {
         }
         describe("inserts 3d element and round-trips through JSON", async () => {
             async function test(annotation) {
-                const el0 = createElement3d();
+                const el0 = createElement3d(imodel, { ...createElement3dArgs });
                 if (annotation) {
                     el0.setAnnotation(annotation);
                 }
@@ -198,42 +217,30 @@ describe("TextAnnotation element", () => {
                 }
             }
             it("roundtrips an empty annotation", async () => { await test(); });
-            it("roundtrips an annotation with a style", async () => { await test(TextAnnotation.fromJSON({ textBlock: { styleId: seedStyleId } })); });
             it("roundtrips an annotation with a textBlock", async () => { await test(createAnnotation()); });
         });
     });
     describe("TextAnnotation2d Persistence", () => {
         let imodel;
-        let seedCategoryId;
-        let seedModelId;
-        let seedStyleId;
+        let createElement2dArgs;
         before(async () => {
             imodel = await createIModel("TextAnnotation2d");
             const jobSubjectId = createJobSubjectElement(imodel, "Job").insert();
             const definitionModel = DefinitionModel.insert(imodel, jobSubjectId, "Definition");
             const { category, model } = insertDrawingModel(imodel, jobSubjectId, definitionModel);
-            const styleId = createAnnotationTextStyle(imodel, definitionModel, "test", { fontName: "Totally Real Font", lineHeight: 0.25, isItalic: true }).insert();
             expect(jobSubjectId).not.to.be.undefined;
             expect(category).not.to.be.undefined;
             expect(model).not.to.be.undefined;
-            expect(styleId).not.to.be.undefined;
-            seedCategoryId = category;
-            seedModelId = model;
-            seedStyleId = styleId;
+            createElement2dArgs = { category, model };
         });
         after(() => {
             imodel.saveChanges("tests");
             imodel.close();
         });
-        function createElement2d(createArgs) {
-            return TextAnnotation2d.create(imodel, seedCategoryId, seedModelId, {
-                origin: { x: 0, y: 0 },
-                angle: Angle.createDegrees(0).toJSON(),
-            }, createArgs?.textAnnotationData);
-        }
         it("creating element does not automatically compute the geometry", () => {
             const annotation = createAnnotation();
-            const el = createElement2d({ textAnnotationData: annotation.toJSON() });
+            const args = { ...createElement2dArgs, textAnnotationData: annotation.toJSON() };
+            const el = createElement2d(imodel, args);
             expect(el.getAnnotation().equals(annotation)).to.be.true;
             expect(el.geom).to.be.undefined;
         });
@@ -245,7 +252,7 @@ describe("TextAnnotation element", () => {
         }
         describe("inserts 2d element and round-trips through JSON", async () => {
             async function test(annotation) {
-                const el0 = createElement2d();
+                const el0 = createElement2d(imodel, createElement2dArgs);
                 if (annotation) {
                     el0.setAnnotation(annotation);
                 }
@@ -265,13 +272,127 @@ describe("TextAnnotation element", () => {
                     expect(anno).not.to.be.undefined;
                     expect(anno.equals(annotation)).to.be.true;
                     expect(el0.toJSON().elementGeometryBuilderParams).not.to.be.undefined;
+                    expect(el0.toJSON().elementGeometryBuilderParams).to.deep.equal(el1.toJSON().elementGeometryBuilderParams);
                 }
             }
             it("roundtrips an empty annotation", async () => { await test(); });
-            it("roundtrips an annotation with a style", async () => { await test(TextAnnotation.fromJSON({ textBlock: { styleId: seedStyleId } })); });
             it("roundtrips an annotation with a textBlock", async () => { await test(createAnnotation()); });
         });
     });
+    describe("defaultTextStyle", () => {
+        let imodel;
+        let seedSubjectId;
+        let seedDefinitionModelId;
+        let seedStyleId;
+        let seedStyleId2;
+        before(async () => {
+            imodel = await createIModel("DefaultTextStyle");
+            const jobSubjectId = createJobSubjectElement(imodel, "Job").insert();
+            const definitionModel = DefinitionModel.insert(imodel, jobSubjectId, "Definition");
+            const styleId = createAnnotationTextStyle(imodel, definitionModel, "test", { fontName: "Totally Real Font", lineHeight: 0.25, isItalic: true }).insert();
+            const differentStyleId = createAnnotationTextStyle(imodel, definitionModel, "alt", { fontName: "Karla", lineHeight: 0.5, isBold: true }).insert();
+            expect(jobSubjectId).not.to.be.undefined;
+            expect(definitionModel).not.to.be.undefined;
+            expect(styleId).not.to.be.undefined;
+            expect(differentStyleId).not.to.be.undefined;
+            seedSubjectId = jobSubjectId;
+            seedDefinitionModelId = definitionModel;
+            seedStyleId = styleId;
+            seedStyleId2 = differentStyleId;
+        });
+        after(() => {
+            imodel.saveChanges("tests");
+            imodel.close();
+        });
+        describe("TextAnnotation2d", () => {
+            let createElement2dArgs;
+            before(() => {
+                const { category, model } = insertDrawingModel(imodel, seedSubjectId, seedDefinitionModelId);
+                expect(category).not.to.be.undefined;
+                expect(model).not.to.be.undefined;
+                createElement2dArgs = { category, model };
+            });
+            it("preserves defaultTextStyle after round trip", () => {
+                const annotation = createAnnotation();
+                const args = { ...createElement2dArgs, textAnnotationData: annotation.toJSON(), defaultTextStyleId: seedStyleId };
+                const el0 = createElement2d(imodel, args);
+                expect(el0.defaultTextStyle).not.to.be.undefined;
+                expect(el0.defaultTextStyle.id).to.equal(seedStyleId);
+                el0.insert();
+                const el1 = imodel.elements.getElement(el0.id);
+                expect(el1).not.to.be.undefined;
+                expect(el1.defaultTextStyle).not.to.be.undefined;
+                expect(el1.defaultTextStyle.id).to.equal(seedStyleId);
+                expect(el0.toJSON().elementGeometryBuilderParams).to.deep.equal(el1.toJSON().elementGeometryBuilderParams);
+            });
+            it("produces different geometry when defaultTextStyle changes", () => {
+                const annotation = createAnnotation();
+                const args = { ...createElement2dArgs, textAnnotationData: annotation.toJSON() };
+                const el0 = createElement2d(imodel, args);
+                el0.defaultTextStyle = new TextAnnotationUsesTextStyleByDefault(seedStyleId);
+                const geom1 = el0.toJSON().elementGeometryBuilderParams;
+                el0.defaultTextStyle = new TextAnnotationUsesTextStyleByDefault(seedStyleId2);
+                const geom2 = el0.toJSON().elementGeometryBuilderParams;
+                expect(geom1).not.to.deep.equal(geom2);
+            });
+            it("allows defaultTextStyle to be undefined", () => {
+                const annotation = createAnnotation();
+                const args = { ...createElement2dArgs, textAnnotationData: annotation.toJSON() };
+                const el0 = createElement2d(imodel, args);
+                el0.defaultTextStyle = 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;
+                expect(el1.defaultTextStyle).to.be.undefined;
+            });
+        });
+        describe("TextAnnotation3d", () => {
+            let createElement3dArgs;
+            before(() => {
+                const { category, model } = insertSpatialModel(imodel, seedSubjectId, seedDefinitionModelId);
+                expect(category).not.to.be.undefined;
+                expect(model).not.to.be.undefined;
+                createElement3dArgs = { category, model };
+            });
+            it("preserves defaultTextStyle after round trip", () => {
+                const annotation = createAnnotation();
+                const args = { ...createElement3dArgs, textAnnotationData: annotation.toJSON(), defaultTextStyleId: seedStyleId };
+                const el0 = createElement3d(imodel, args);
+                expect(el0.defaultTextStyle).not.to.be.undefined;
+                expect(el0.defaultTextStyle.id).to.equal(seedStyleId);
+                el0.insert();
+                const el1 = imodel.elements.getElement(el0.id);
+                expect(el1).not.to.be.undefined;
+                expect(el1.defaultTextStyle).not.to.be.undefined;
+                expect(el1.defaultTextStyle.id).to.equal(seedStyleId);
+                expect(el0.toJSON().elementGeometryBuilderParams).to.deep.equal(el1.toJSON().elementGeometryBuilderParams);
+            });
+            it("produces different geometry when defaultTextStyle changes", () => {
+                const annotation = createAnnotation();
+                const args = { ...createElement3dArgs, textAnnotationData: annotation.toJSON() };
+                const el0 = createElement3d(imodel, args);
+                el0.defaultTextStyle = new TextAnnotationUsesTextStyleByDefault(seedStyleId);
+                const geom1 = el0.toJSON().elementGeometryBuilderParams;
+                el0.defaultTextStyle = new TextAnnotationUsesTextStyleByDefault(seedStyleId2);
+                const geom2 = el0.toJSON().elementGeometryBuilderParams;
+                expect(geom1).not.to.deep.equal(geom2);
+            });
+            it("allows defaultTextStyle to be undefined", () => {
+                const annotation = createAnnotation();
+                const args = { ...createElement3dArgs, textAnnotationData: annotation.toJSON() };
+                const el0 = createElement3d(imodel, args);
+                el0.defaultTextStyle = 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;
+                expect(el1.defaultTextStyle).to.be.undefined;
+            });
+        });
+    });
 });
 describe("AnnotationTextStyle", () => {
     let imodel;
@@ -354,4 +475,139 @@ describe("AnnotationTextStyle", () => {
         expect(el0.settings.toJSON()).to.deep.equal(newStyle.toJSON());
     });
 });
+describe("appendTextAnnotationGeometry", () => {
+    let imodel;
+    let seedDefinitionModelId;
+    let seedCategoryId;
+    let seedStyleId;
+    let seedStyleId2;
+    before(async () => {
+        imodel = await createIModel("DefaultTextStyle");
+        const jobSubjectId = createJobSubjectElement(imodel, "Job").insert();
+        const definitionModel = DefinitionModel.insert(imodel, jobSubjectId, "Definition");
+        const { category, model } = insertDrawingModel(imodel, jobSubjectId, definitionModel);
+        const styleId = createAnnotationTextStyle(imodel, definitionModel, "test", { fontName: "Totally Real Font", lineHeight: 0.25, isItalic: true }).insert();
+        const differentStyleId = createAnnotationTextStyle(imodel, definitionModel, "alt", { fontName: "Karla", lineHeight: 0.5, isBold: true }).insert();
+        expect(jobSubjectId).not.to.be.undefined;
+        expect(definitionModel).not.to.be.undefined;
+        expect(category).not.to.be.undefined;
+        expect(model).not.to.be.undefined;
+        expect(styleId).not.to.be.undefined;
+        expect(differentStyleId).not.to.be.undefined;
+        seedDefinitionModelId = definitionModel;
+        seedCategoryId = category;
+        seedStyleId = styleId;
+        seedStyleId2 = differentStyleId;
+    });
+    function runAppendTextAnnotationGeometry(annotation, styleId, scaleFactor = 1) {
+        const builder = new MockBuilder();
+        const resolver = new TextStyleResolver({
+            textBlock: annotation.textBlock,
+            textStyleId: styleId,
+            iModel: imodel,
+        });
+        const layout = layoutTextBlock({
+            textBlock: annotation.textBlock,
+            iModel: imodel,
+            textStyleResolver: resolver,
+        });
+        const result = appendTextAnnotationGeometry({
+            annotationProps: annotation.toJSON(),
+            layout,
+            textStyleResolver: resolver,
+            scaleFactor,
+            builder,
+            categoryId: seedCategoryId,
+        });
+        expect(result).to.be.true;
+        return builder;
+    }
+    it("produces the same geometry when given the same inputs", () => {
+        const builder1 = runAppendTextAnnotationGeometry(createAnnotation(), seedStyleId);
+        const builder2 = runAppendTextAnnotationGeometry(createAnnotation(), seedStyleId);
+        expect(builder1.geometries).to.deep.equal(builder2.geometries);
+        expect(builder1.params).to.deep.equal(builder2.params);
+        expect(builder1.textStrings).to.deep.equal(builder2.textStrings);
+    });
+    it("produces no geometry when given an empty annotation", () => {
+        const block = TextBlock.create();
+        const annotation = TextAnnotation.fromJSON({ textBlock: block.toJSON() });
+        const builder = runAppendTextAnnotationGeometry(annotation, seedStyleId);
+        expect(builder.geometries).to.be.empty;
+        expect(builder.params).to.be.empty;
+        expect(builder.textStrings).to.be.empty;
+    });
+    it("produces geometry when given an empty annotation with frame styling", () => {
+        const block = TextBlock.create();
+        const annotation = TextAnnotation.fromJSON({ textBlock: block.toJSON() });
+        const styleId = createAnnotationTextStyle(imodel, seedDefinitionModelId, "empty anno style", {
+            fontName: "Totally Real Font",
+            frame: {
+                shape: "rectangle",
+            }
+        }).insert();
+        const builder = runAppendTextAnnotationGeometry(annotation, styleId);
+        expect(builder.geometries).not.to.be.empty;
+        expect(builder.params).not.to.be.empty;
+        expect(builder.textStrings).to.be.empty;
+    });
+    it("produces different geometry when given different text-content in annotations", () => {
+        const anno1 = createAnnotation();
+        const anno2 = createAnnotation();
+        anno2.textBlock.appendRun(TextRun.create({ content: "extra", styleOverrides: { fontName: "Totally Real Font" } }));
+        const builder1 = runAppendTextAnnotationGeometry(anno1, seedStyleId);
+        const builder2 = runAppendTextAnnotationGeometry(anno2, seedStyleId);
+        expect(builder1.geometries).to.not.deep.equal(builder2.geometries);
+        expect(builder1.params).to.deep.equal(builder2.params);
+        expect(builder1.textStrings).to.not.deep.equal(builder2.textStrings);
+    });
+    it("produces different geometry when given different default styles", () => {
+        const builder1 = runAppendTextAnnotationGeometry(createAnnotation(), seedStyleId);
+        const builder2 = runAppendTextAnnotationGeometry(createAnnotation(), seedStyleId2);
+        expect(builder1.geometries).to.not.deep.equal(builder2.geometries);
+        expect(builder1.textStrings).to.not.deep.equal(builder2.textStrings);
+    });
+    it("accounts for style overrides in the text", () => {
+        const block = TextBlock.create();
+        block.appendParagraph();
+        block.children[0].styleOverrides = { isBold: true };
+        block.appendRun(TextRun.create({ content: "Run, Barry," }));
+        block.appendParagraph();
+        block.appendRun(TextRun.create({ content: " RUN!!! ", styleOverrides: { isItalic: false } }));
+        block.margins = { left: 0, right: 1, top: 2, bottom: 3 };
+        const annotation = createAnnotation(block);
+        const builder = runAppendTextAnnotationGeometry(annotation, seedStyleId);
+        expect(builder.textStrings.length).to.equal(2);
+        expect(builder.textStrings[0].text).to.equal("Run, Barry,");
+        // From override on paragraph
+        expect(builder.textStrings[0].bold).to.be.true;
+        // From default style
+        expect(builder.textStrings[0].italic).to.be.true;
+        expect(builder.textStrings[1].text).to.equal(" RUN!!! ");
+        // From default style
+        expect(builder.textStrings[1].bold).to.be.false;
+        // From override on run
+        expect(builder.textStrings[1].italic).to.be.false;
+    });
+    it("uses TextStyleSettings.defaults when no default style is provided", () => {
+        const block = TextBlock.create();
+        block.appendRun(TextRun.create({ content: "Run, Barry," }));
+        block.margins = { left: 0, right: 1, top: 2, bottom: 3 };
+        const annotation = createAnnotation(block);
+        const builder = runAppendTextAnnotationGeometry(annotation, "");
+        expect(builder.textStrings.length).to.equal(1);
+        expect(builder.textStrings[0].text).to.equal("Run, Barry,");
+        expect(builder.textStrings[0].font).to.equal(0); // Font ID 0 is the "missing" font in the default text style
+        expect(builder.textStrings[0].bold).to.equal(TextStyleSettings.defaultProps.isBold);
+        expect(builder.textStrings[0].italic).to.equal(TextStyleSettings.defaultProps.isItalic);
+        expect(builder.textStrings[0].underline).to.equal(TextStyleSettings.defaultProps.isUnderlined);
+    });
+    it("scales geometry correctly", () => {
+        const annotation = createAnnotation();
+        const builder1 = runAppendTextAnnotationGeometry(annotation, seedStyleId, 1);
+        const builder2 = runAppendTextAnnotationGeometry(annotation, seedStyleId, 2);
+        expect(builder1.textStrings[0].height * 2).to.equal(builder2.textStrings[0].height);
+        expect(builder1.textStrings[0].width * 2).to.equal(builder2.textStrings[0].width);
+    });
+});
 //# sourceMappingURL=TextAnnotation.test.js.map