@itwin/core-backend 5.3.0-dev.6 → 5.3.0-dev.8

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

@@ -4,9 +4,9 @@
 *--------------------------------------------------------------------------------------------*/
 import { expect } from "chai";
 import { Angle, Point3d, Range2d, Range3d, YawPitchRollAngles } from "@itwin/core-geometry";
-import { FractionRun, SubCategoryAppearance, TextAnnotation, TextBlock, TextRun, TextStyleSettings } from "@itwin/core-common";
+import { FieldRun, FractionRun, SubCategoryAppearance, TextAnnotation, TextBlock, TextRun, TextStyleSettings } from "@itwin/core-common";
 import { StandaloneDb } from "../../IModelDb";
-import { AnnotationTextStyle, TEXT_ANNOTATION_JSON_VERSION, TEXT_STYLE_SETTINGS_JSON_VERSION, TextAnnotation2d, TextAnnotation3d } from "../../annotations/TextAnnotationElement";
+import { AnnotationTextStyle, parseTextAnnotationData, TEXT_ANNOTATION_JSON_VERSION, TEXT_STYLE_SETTINGS_JSON_VERSION, TextAnnotation2d, TextAnnotation3d } from "../../annotations/TextAnnotationElement";
 import { IModelTestUtils } from "../IModelTestUtils";
 import { Subject } from "../../Element";
 import { Guid, Id64 } from "@itwin/core-bentley";
@@ -19,6 +19,7 @@ import { computeTextRangeAsStringLength, MockBuilder } from "../AnnotationTestUt
 import { TextAnnotationUsesTextStyleByDefault } from "../../annotations/ElementDrivesTextAnnotation";
 import { layoutTextBlock, TextStyleResolver } from "../../annotations/TextBlockLayout";
 import { appendTextAnnotationGeometry } from "../../annotations/TextAnnotationGeometry";
+import { IModelElementCloneContext } from "../../IModelElementCloneContext";
 function mockIModel() {
     const iModel = {
         fonts: {
@@ -212,6 +213,58 @@ describe("TextAnnotation element", () => {
             expect(elem.getAnnotation().toJSON()).not.to.equal(annotation.toJSON());
         });
     });
+    describe("getReferenceIds", () => {
+        function expectReferenceIds(expected, element) {
+            const actual = Array.from(element.getReferenceIds()).sort();
+            // reference Ids get a prefix indicating their type ('e' for 'element')
+            expected = expected.map((id) => `e${id}`);
+            // the superclasses provide some reference Ids (code spec, model, category)
+            const baseIds = ["e0x12", "e0x78", "m0x34"];
+            expected.push(...baseIds);
+            expected = expected.sort();
+            expect(actual).to.deep.equal(expected);
+        }
+        it("reports default text style and field hosts", () => {
+            // makeElement sets defaultTextStyle to "0x21"
+            const elem = makeElement();
+            expectReferenceIds(["0x21"], elem);
+            elem.defaultTextStyle = new TextAnnotationUsesTextStyleByDefault("0x123");
+            expectReferenceIds(["0x123"], elem);
+            const textBlock = TextBlock.create();
+            textBlock.appendRun(FieldRun.create({
+                propertyHost: { elementId: "0x456", schemaName: "BisCore", className: "GeometricElement3d" },
+                propertyPath: { propertyName: "CodeValue" },
+            }));
+            textBlock.appendRun(FieldRun.create({
+                propertyHost: { elementId: "0x789", schemaName: "BisCore", className: "GeometricElement3d" },
+                propertyPath: { propertyName: "LastMod" },
+            }));
+            elem.setAnnotation(TextAnnotation.create({ textBlock }));
+            expectReferenceIds(["0x123", "0x456", "0x789"], elem);
+            elem.defaultTextStyle = undefined;
+            expectReferenceIds(["0x456", "0x789"], elem);
+            elem.setAnnotation(TextAnnotation.create());
+            expectReferenceIds([], elem);
+        });
+        it("does not report invalid Ids", () => {
+            const elem = makeElement();
+            elem.defaultTextStyle = undefined;
+            expectReferenceIds([], elem);
+            elem.defaultTextStyle = new TextAnnotationUsesTextStyleByDefault("0");
+            expectReferenceIds([], elem);
+            const textBlock = TextBlock.create();
+            textBlock.appendRun(FieldRun.create({
+                propertyHost: { elementId: "0", schemaName: "BisCore", className: "GeometricElement3d" },
+                propertyPath: { propertyName: "CodeValue" },
+            }));
+            textBlock.appendRun(FieldRun.create({
+                propertyHost: { elementId: "0x123", schemaName: "BisCore", className: "GeometricElement3d" },
+                propertyPath: { propertyName: "LastMod" },
+            }));
+            elem.setAnnotation(TextAnnotation.create({ textBlock }));
+            expectReferenceIds(["0x123"], elem);
+        });
+    });
     describe("TextAnnotation3d Persistence", () => {
         let imodel;
         let createElement3dArgs;
@@ -399,6 +452,178 @@ describe("TextAnnotation element", () => {
                 expect(el1 instanceof TextAnnotation2d).to.be.true;
                 expect(el1.defaultTextStyle).to.be.undefined;
             });
+            describe("onCloned", () => {
+                function insertStyledElement(styleId, db) {
+                    const args = { ...createElement2dArgs, defaultTextStyleId: styleId };
+                    const elem = createElement2d(db, args);
+                    elem.insert();
+                    imodel.saveChanges();
+                    return elem;
+                }
+                describe("within a single iModel", () => {
+                    it("leaves property hosts intact", () => {
+                        const textBlock = TextBlock.create({
+                            children: [{
+                                    children: [{
+                                            type: "field",
+                                            propertyHost: {
+                                                elementId: "0x123",
+                                                schemaName: "Fields",
+                                                className: "TestElement",
+                                            },
+                                            propertyPath: { propertyName: "intProp" },
+                                        }, {
+                                            type: "field",
+                                            propertyHost: {
+                                                elementId: "0xabc",
+                                                schemaName: "BisCore",
+                                                className: "Element",
+                                            },
+                                            propertyPath: { propertyName: "CodeValue" },
+                                        }],
+                                }],
+                        });
+                        const annotation = TextAnnotation.create({ textBlock });
+                        const elem = createElement2d(imodel, { ...createElement2dArgs, textAnnotationProps: annotation.toJSON() });
+                        elem.insert();
+                        imodel.saveChanges();
+                        const context = new IModelElementCloneContext(imodel);
+                        context.remapElement("0x123", "0x456");
+                        context.remapElement("0xabc", "0xdef");
+                        context.remapElement(createElement2dArgs.model, createElement2dArgs.model);
+                        const props = 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) {
+                            const elem = insertStyledElement(styleId, imodel);
+                            const context = new IModelElementCloneContext(imodel);
+                            context.remapElement(createElement2dArgs.model, createElement2dArgs.model);
+                            const props = 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);
+                                expect(props2.defaultTextStyle?.id).to.equal(expectedStyleId);
+                            }
+                        }
+                        clone(seedStyleId, seedStyleId);
+                        clone(undefined, undefined);
+                        clone("0x12345", "0x12345");
+                        clone(Id64.invalid, undefined);
+                    });
+                });
+                describe("between iModels", () => {
+                    let dstDb;
+                    let dstDefModel;
+                    let dstElemArgs;
+                    before(async () => {
+                        dstDb = await createIModel("CloneTarget");
+                        const jobSubjectId = createJobSubjectElement(dstDb, "Job").insert();
+                        dstDefModel = DefinitionModel.insert(dstDb, jobSubjectId, "Definition");
+                        const { category, model } = insertDrawingModel(dstDb, jobSubjectId, dstDefModel);
+                        expect(category).not.to.equal(createElement2dArgs.category);
+                        expect(model).not.to.equal(createElement2dArgs.model);
+                        dstElemArgs = { category, model };
+                    });
+                    after(() => dstDb.close());
+                    it("remaps property hosts", () => {
+                        const textBlock = TextBlock.create({
+                            children: [{
+                                    children: [{
+                                            type: "field",
+                                            propertyHost: {
+                                                elementId: "0x123",
+                                                schemaName: "Fields",
+                                                className: "TestElement",
+                                            },
+                                            propertyPath: { propertyName: "intProp" },
+                                        }, {
+                                            type: "field",
+                                            propertyHost: {
+                                                elementId: "0xabc",
+                                                schemaName: "BisCore",
+                                                className: "Element",
+                                            },
+                                            propertyPath: { propertyName: "CodeValue" },
+                                        }],
+                                }],
+                        });
+                        const annotation = TextAnnotation.create({ textBlock });
+                        const elem = createElement2d(imodel, { ...createElement2dArgs, textAnnotationProps: annotation.toJSON() });
+                        elem.insert();
+                        imodel.saveChanges();
+                        const context = new IModelElementCloneContext(imodel, dstDb);
+                        context.remapElement("0x123", "0x456");
+                        context.remapElement("0xabc", "0xdef");
+                        context.remapElement(createElement2dArgs.model, dstElemArgs.model);
+                        const props = 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", () => {
+                        const elem = insertStyledElement("0x12345", imodel);
+                        const context = new IModelElementCloneContext(imodel, dstDb);
+                        context.remapElement(createElement2dArgs.model, dstElemArgs.model);
+                        const props = context.cloneElement(elem);
+                        expect(props.defaultTextStyle).to.be.undefined;
+                    });
+                    it("remaps to an existing text style with the same code if present", () => {
+                        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);
+                        expect(props.defaultTextStyle?.id).to.equal(dstStyleId);
+                    });
+                    it("throws an error if definition model is not remapped", () => {
+                        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");
+                    });
+                    it("imports default text style if necessary", () => {
+                        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 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", () => {
+                        const srcStyleId = createAnnotationTextStyle(imodel, seedDefinitionModelId, "styyyle", { font: { name: "Karla" } }).insert();
+                        const srcElem1 = insertStyledElement(srcStyleId, imodel);
+                        const srcElem2 = insertStyledElement(srcStyleId, imodel);
+                        const srcElem3 = insertStyledElement(srcStyleId, imodel);
+                        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);
+                        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);
+                        expect(props3.defaultTextStyle?.id).to.equal(props1.defaultTextStyle?.id);
+                    });
+                });
+            });
         });
         describe("TextAnnotation3d", () => {
             let createElement3dArgs;