@itwin/core-backend 5.3.0-dev.9 → 5.3.0

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

@@ -4,7 +4,7 @@
 *--------------------------------------------------------------------------------------------*/
 import { expect } from "chai";
 import { Angle, Point3d, Range2d, Range3d, YawPitchRollAngles } from "@itwin/core-geometry";
-import { FieldRun, FractionRun, SubCategoryAppearance, TextAnnotation, TextBlock, TextRun, TextStyleSettings } from "@itwin/core-common";
+import { FieldRun, FontType, FractionRun, SubCategoryAppearance, TextAnnotation, TextBlock, TextRun, TextStyleSettings } from "@itwin/core-common";
 import { StandaloneDb } from "../../IModelDb";
 import { AnnotationTextStyle, parseTextAnnotationData, TEXT_ANNOTATION_JSON_VERSION, TEXT_STYLE_SETTINGS_JSON_VERSION, TextAnnotation2d, TextAnnotation3d } from "../../annotations/TextAnnotationElement";
 import { IModelTestUtils } from "../IModelTestUtils";
@@ -20,6 +20,7 @@ import { TextAnnotationUsesTextStyleByDefault } from "../../annotations/ElementD
 import { layoutTextBlock, TextStyleResolver } from "../../annotations/TextBlockLayout";
 import { appendTextAnnotationGeometry } from "../../annotations/TextAnnotationGeometry";
 import { IModelElementCloneContext } from "../../IModelElementCloneContext";
+import * as fs from "fs";
 function mockIModel() {
     const iModel = {
         fonts: {
@@ -461,8 +462,9 @@ describe("TextAnnotation element", () => {
                     return elem;
                 }
                 describe("within a single iModel", () => {
-                    it("leaves property hosts intact", () => {
+                    it("leaves property hosts intact", async () => {
                         const textBlock = TextBlock.create({
+                            styleOverrides: { font: { name: "Karla" } },
                             children: [{
                                     children: [{
                                             type: "field",
@@ -483,7 +485,7 @@ describe("TextAnnotation element", () => {
                                         }],
                                 }],
                         });
-                        const annotation = TextAnnotation.create({ textBlock });
+                        const annotation = TextAnnotation.create({ textBlock, });
                         const elem = createElement2d(imodel, { ...createElement2dArgs, textAnnotationProps: annotation.toJSON() });
                         elem.insert();
                         imodel.saveChanges();
@@ -491,32 +493,32 @@ describe("TextAnnotation element", () => {
                         context.remapElement("0x123", "0x456");
                         context.remapElement("0xabc", "0xdef");
                         context.remapElement(createElement2dArgs.model, createElement2dArgs.model);
-                        const props = context.cloneElement(elem);
+                        const props = await context.cloneElement(elem);
                         expect(props.textAnnotationData).not.to.be.undefined;
                         const anno = TextAnnotation.fromJSON(parseTextAnnotationData(props.textAnnotationData)?.data);
                         const para = anno.textBlock.children[0];
                         expect(para.children[0].propertyHost.elementId).to.equal("0x123");
                         expect(para.children[1].propertyHost.elementId).to.equal("0xabc");
                     });
-                    it("leaves default text style intact", () => {
-                        function clone(styleId, expectedStyleId) {
+                    it("leaves default text style intact", async () => {
+                        async function clone(styleId, expectedStyleId) {
                             const elem = insertStyledElement(styleId, imodel);
                             const context = new IModelElementCloneContext(imodel);
                             context.remapElement(createElement2dArgs.model, createElement2dArgs.model);
-                            const props = context.cloneElement(elem);
+                            const props = await context.cloneElement(elem);
                             expect(props.defaultTextStyle?.id).to.equal(expectedStyleId);
                             if (styleId) {
                                 // Even an explicit remapping is ignored when cloning within a single iModel
                                 // (per the examples set by most other elements, excluding RenderMaterial).
                                 context.remapElement(styleId, "0x99887");
-                                const props2 = context.cloneElement(elem);
+                                const props2 = await context.cloneElement(elem);
                                 expect(props2.defaultTextStyle?.id).to.equal(expectedStyleId);
                             }
                         }
-                        clone(seedStyleId, seedStyleId);
-                        clone(undefined, undefined);
-                        clone("0x12345", "0x12345");
-                        clone(Id64.invalid, undefined);
+                        await clone(seedStyleId, seedStyleId);
+                        await clone(undefined, undefined);
+                        await clone("0x12345", "0x12345");
+                        await clone(Id64.invalid, undefined);
                     });
                 });
                 describe("between iModels", () => {
@@ -533,8 +535,9 @@ describe("TextAnnotation element", () => {
                         dstElemArgs = { category, model };
                     });
                     after(() => dstDb.close());
-                    it("remaps property hosts", () => {
+                    it("remaps property hosts", async () => {
                         const textBlock = TextBlock.create({
+                            styleOverrides: { font: { name: "Karla" } },
                             children: [{
                                     children: [{
                                             type: "field",
@@ -563,47 +566,47 @@ describe("TextAnnotation element", () => {
                         context.remapElement("0x123", "0x456");
                         context.remapElement("0xabc", "0xdef");
                         context.remapElement(createElement2dArgs.model, dstElemArgs.model);
-                        const props = context.cloneElement(elem);
+                        const props = await context.cloneElement(elem);
                         expect(props.textAnnotationData).not.to.be.undefined;
                         const anno = TextAnnotation.fromJSON(parseTextAnnotationData(props.textAnnotationData)?.data);
                         const para = anno.textBlock.children[0];
                         expect(para.children[0].propertyHost.elementId).to.equal("0x456");
                         expect(para.children[1].propertyHost.elementId).to.equal("0xdef");
                     });
-                    it("sets default text style to undefined if source style does not exist", () => {
+                    it("sets default text style to undefined if source style does not exist", async () => {
                         const elem = insertStyledElement("0x12345", imodel);
                         const context = new IModelElementCloneContext(imodel, dstDb);
                         context.remapElement(createElement2dArgs.model, dstElemArgs.model);
-                        const props = context.cloneElement(elem);
+                        const props = await context.cloneElement(elem);
                         expect(props.defaultTextStyle).to.be.undefined;
                     });
-                    it("remaps to an existing text style with the same code if present", () => {
+                    it("remaps to an existing text style with the same code if present", async () => {
                         const dstStyleId = createAnnotationTextStyle(dstDb, dstDefModel, "test", { font: { name: "Karla" } }).insert();
                         expect(dstStyleId).not.to.equal(seedStyleId);
                         const srcElem = insertStyledElement(seedStyleId, imodel);
                         const context = new IModelElementCloneContext(imodel, dstDb);
                         context.remapElement(createElement2dArgs.model, dstElemArgs.model);
-                        const props = context.cloneElement(srcElem);
+                        const props = await context.cloneElement(srcElem);
                         expect(props.defaultTextStyle?.id).to.equal(dstStyleId);
                     });
-                    it("throws an error if definition model is not remapped", () => {
+                    it("throws an error if definition model is not remapped", async () => {
                         const srcElem = insertStyledElement(seedStyleId2, imodel);
                         const context = new IModelElementCloneContext(imodel, dstDb);
                         context.remapElement(createElement2dArgs.model, dstElemArgs.model);
-                        expect(() => context.cloneElement(srcElem)).to.throw("Invalid target model");
+                        await expect(context.cloneElement(srcElem)).to.be.rejectedWith("Invalid target model");
                     });
-                    it("imports default text style if necessary", () => {
+                    it("imports default text style if necessary", async () => {
                         const srcElem = insertStyledElement(seedStyleId2, imodel);
                         const context = new IModelElementCloneContext(imodel, dstDb);
                         context.remapElement(createElement2dArgs.model, dstElemArgs.model);
                         context.remapElement(seedDefinitionModelId, dstDefModel);
-                        const props = context.cloneElement(srcElem);
+                        const props = await context.cloneElement(srcElem);
                         const dstStyleId = props.defaultTextStyle.id;
                         expect(dstStyleId).not.to.be.undefined;
                         expect(dstStyleId).not.to.equal(seedStyleId2);
                         expect(dstDb.elements.tryGetElement(dstStyleId)).not.to.be.undefined;
                     });
-                    it("remaps multiple occurrences of same style to same Id", () => {
+                    it("remaps multiple occurrences of same style to same Id", async () => {
                         const srcStyleId = createAnnotationTextStyle(imodel, seedDefinitionModelId, "styyyle", { font: { name: "Karla" } }).insert();
                         const srcElem1 = insertStyledElement(srcStyleId, imodel);
                         const srcElem2 = insertStyledElement(srcStyleId, imodel);
@@ -611,15 +614,15 @@ describe("TextAnnotation element", () => {
                         const context = new IModelElementCloneContext(imodel, dstDb);
                         context.remapElement(createElement2dArgs.model, dstElemArgs.model);
                         context.remapElement(seedDefinitionModelId, dstDefModel);
-                        const props1 = context.cloneElement(srcElem1);
-                        const props2 = context.cloneElement(srcElem2);
+                        const props1 = await context.cloneElement(srcElem1);
+                        const props2 = await context.cloneElement(srcElem2);
                         expect(props1.defaultTextStyle).not.to.be.undefined;
                         expect(props1.defaultTextStyle?.id).not.to.equal(srcStyleId);
                         expect(props2.defaultTextStyle?.id).to.equal(props1.defaultTextStyle?.id);
                         const context2 = new IModelElementCloneContext(imodel, dstDb);
                         context2.remapElement(createElement2dArgs.model, dstElemArgs.model);
                         context2.remapElement(seedDefinitionModelId, dstDefModel);
-                        const props3 = context2.cloneElement(srcElem3);
+                        const props3 = await context2.cloneElement(srcElem3);
                         expect(props3.defaultTextStyle?.id).to.equal(props1.defaultTextStyle?.id);
                     });
                 });
@@ -786,13 +789,99 @@ describe("AnnotationTextStyle", () => {
                 }),
             })).to.throw(`JSON version 999.999.999 is newer than supported version ${TEXT_STYLE_SETTINGS_JSON_VERSION}. Application update required to understand data.`);
         });
-        it("throws if the JSON version is old and cannot be migrated", () => {
-            expect(() => makeStyle({
+        it("should migrate text style settings from 1.0.0", () => {
+            const oldStyleData = {
+                ...TextStyleSettings.defaultProps,
+                leader: {
+                    ...TextStyleSettings.defaultProps.leader,
+                    // Explicitly remove terminatorShape to simulate old data
+                    terminatorShape: undefined
+                }
+            };
+            const migratedStyle = makeStyle({
                 settings: JSON.stringify({
-                    version: "0.0.1",
-                    data: TextStyleSettings.defaultProps
+                    version: "1.0.0",
+                    data: oldStyleData
                 }),
-            })).to.throw(`Migration for settings from version 0.0.1 to ${TEXT_STYLE_SETTINGS_JSON_VERSION} failed.`);
+            });
+            const jsonStyleData = migratedStyle.toJSON();
+            if (jsonStyleData.settings) {
+                const jsonVersion = JSON.parse(jsonStyleData.settings).version;
+                expect(jsonVersion).to.equal(TEXT_STYLE_SETTINGS_JSON_VERSION);
+            }
+            expect(migratedStyle.settings.leader.terminatorShape).to.not.be.undefined;
+        });
+        it("should return same data when version is 1.0.1", () => {
+            const styleData = {
+                version: "1.0.1",
+                data: TextStyleSettings.defaultProps
+            };
+            const migratedStyle = makeStyle({
+                settings: JSON.stringify({
+                    version: styleData.version,
+                    data: styleData.data
+                }),
+            });
+            const jsonStyleData = migratedStyle.toJSON();
+            if (jsonStyleData.settings) {
+                const parsedJson = JSON.parse(jsonStyleData.settings);
+                expect(parsedJson.version).to.equal(styleData.version);
+                expect(parsedJson.data).to.deep.equal(styleData.data);
+            }
+        });
+        it("should return defaultProps when styleData is unrecognized", () => {
+            const textStyle = makeStyle({
+                settings: JSON.stringify({
+                    version: "1.0.1",
+                    data: { invalid: "data" }
+                }),
+            });
+            expect(textStyle.settings).to.be.deep.equal(TextStyleSettings.defaultProps);
+        });
+    });
+    describe("onCloned", () => {
+        let targetDb;
+        let targetDefModel;
+        before(async () => {
+            // The source and target iModel will both contain the Karla font family.
+            targetDb = await createIModel("AnnotationTextStyleTargetDb");
+            const jobSubjectId = createJobSubjectElement(targetDb, "Job").insert();
+            targetDefModel = DefinitionModel.insert(targetDb, jobSubjectId, "Definition");
+            // Embed a font into the source iModel that doesn't exist in the target iModel.
+            const shxName = IModelTestUtils.resolveFontFile("Cdm.shx");
+            const shxBlob = fs.readFileSync(shxName);
+            const shxFile = FontFile.createFromShxFontBlob({ blob: shxBlob, familyName: "Cdm" });
+            await imodel.fonts.embedFontFile({ file: shxFile });
+        });
+        after(() => targetDb.close());
+        it("embeds font into target Db if not already embedded", async () => {
+            const getFontCounts = () => {
+                let files = 0;
+                for (const _ of targetDb.fonts.queryEmbeddedFontFiles()) {
+                    files++;
+                }
+                let families = 0;
+                for (const _ of targetDb.fonts.queryMappedFamilies()) {
+                    families++;
+                }
+                return { files, families };
+            };
+            const initialCounts = getFontCounts();
+            const karlaStyle = createAnnotationTextStyle(imodel, seedDefinitionModel, "karla-style", TextStyleSettings.fromJSON({ font: { name: "Karla" } }));
+            karlaStyle.insert();
+            const cdmStyle = createAnnotationTextStyle(imodel, seedDefinitionModel, "cdm-style", TextStyleSettings.fromJSON({ font: { name: "Cdm", type: FontType.Shx } }));
+            cdmStyle.insert();
+            const context = new IModelElementCloneContext(imodel, targetDb);
+            context.remapElement(seedDefinitionModel, targetDefModel);
+            expect(targetDb.fonts.findId({ name: "Karla" })).not.to.be.undefined;
+            await context.cloneElement(karlaStyle);
+            expect(getFontCounts()).to.deep.equal(initialCounts);
+            expect(targetDb.fonts.findId({ name: "Cdm", type: FontType.Shx })).to.be.undefined;
+            await context.cloneElement(cdmStyle);
+            expect(targetDb.fonts.findId({ name: "Cdm", type: FontType.Shx })).not.to.be.undefined;
+            const finalCounts = getFontCounts();
+            expect(finalCounts.files).greaterThan(initialCounts.files);
+            expect(finalCounts.families).greaterThan(initialCounts.families);
         });
     });
 });