@configura/babylon-view 1.3.0-alpha.3 → 1.3.0

package/dist/nodes/CfgTransformNode.js

@@ -1,81 +1,83 @@
-import { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
-import { InspectableType } from "@babylonjs/core/Misc/iInspectable.js";
-export class CfgTransformNode extends TransformNode {
-    constructor(_renderEnvironment, name) {
-        super(name, _renderEnvironment.scene);
-        this._renderEnvironment = _renderEnvironment;
-        this.addInspectorProperties();
-    }
-    /**
-     * Provides a class name to show in the Babylon.js Inspector.
-     * Override in subclasses.
-     */
-    get cfgClassName() {
-        return "CfgTransformNode";
-    }
-    getChildrenForAnimation() {
-        const result = [];
-        for (const c of this.getChildren()) {
-            if (c instanceof CfgTransformNode) {
-                result.push(c);
-            }
-        }
-        return result;
-    }
-    clear(dispose) {
-        const children = this.getChildren();
-        if (children.length > 0) {
-            this.remove(dispose, ...children.slice());
-        }
-    }
-    add(...objects) {
-        for (const obj of objects) {
-            if (obj === this) {
-                console.error("CfgTransformNode.add: object can't be added as a child of itself.", obj);
-                continue;
-            }
-            obj.parent = this;
-        }
-    }
-    /// Recursively calculates the world matrix based on originalMatrix on
-    /// nodes which inherits CfgTransformNode.
-    get worldOriginalMatrix() {
-        const o = this.originalMatrix;
-        const p = this.parent;
-        if (p && p instanceof CfgTransformNode) {
-            return o.multiply(p.worldOriginalMatrix);
-        }
-        return o;
-    }
-    remove(dispose, ...objects) {
-        for (const obj of objects) {
-            if (dispose) {
-                obj.dispose();
-            }
-            else {
-                obj.parent = null;
-            }
-        }
-        return this;
-    }
-    /**
-     * Adds the property to the instance so it shows up in the Babylon.js Inspector.
-     *
-     * TODO Babylon: Currently they show up as editable, even though they are used to display
-     * read-only information. Metadata seems to be more correct, but is not (yet?) included by the
-     * Inspector.
-     */
-    addInspectableCustomProperty(property) {
-        if (this.inspectableCustomProperties === undefined) {
-            this.inspectableCustomProperties = [];
-        }
-        this.inspectableCustomProperties.push(property);
-    }
-    addInspectorProperties() {
-        this.addInspectableCustomProperty({
-            label: "Cfg Class",
-            propertyName: "cfgClassName",
-            type: InspectableType.String,
-        });
-    }
-}
+import { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
+import { InspectableType } from "@babylonjs/core/Misc/iInspectable.js";
+export class CfgTransformNode extends TransformNode {
+    constructor(_renderEnvironment, name) {
+        super(name, _renderEnvironment.scene);
+        this._renderEnvironment = _renderEnvironment;
+        this.addInspectorProperties();
+    }
+    /**
+     * Provides a class name to show in the Babylon.js Inspector.
+     * Override in subclasses.
+     */
+    get cfgClassName() {
+        return "CfgTransformNode";
+    }
+    getChildrenForAnimation() {
+        const result = [];
+        for (const c of this.getChildren()) {
+            if (c instanceof CfgTransformNode) {
+                result.push(c);
+            }
+        }
+        return result;
+    }
+    clear(dispose) {
+        const children = this.getChildren();
+        if (children.length > 0) {
+            this.remove(dispose, ...children.slice());
+        }
+    }
+    add(...objects) {
+        for (const obj of objects) {
+            if (obj === this) {
+                console.error("CfgTransformNode.add: object can't be added as a child of itself.", obj);
+                continue;
+            }
+            obj.parent = this;
+        }
+    }
+    /**
+     * Recursively calculates the world matrix based on originalMatrix on nodes which inherits
+     * CfgTransformNode.
+     */
+    get worldOriginalMatrix() {
+        const o = this.originalMatrix;
+        const p = this.parent;
+        if (p && p instanceof CfgTransformNode) {
+            return o.multiply(p.worldOriginalMatrix);
+        }
+        return o;
+    }
+    remove(dispose, ...objects) {
+        for (const obj of objects) {
+            if (dispose) {
+                obj.dispose();
+            }
+            else {
+                obj.parent = null;
+            }
+        }
+        return this;
+    }
+    /**
+     * Adds the property to the instance so it shows up in the Babylon.js Inspector.
+     *
+     * TODO Babylon: Currently they show up as editable, even though they are used to display
+     * read-only information. Metadata seems to be more correct, but is not (yet?) included by the
+     * Inspector.
+     */
+    addInspectableCustomProperty(property) {
+        if (this.inspectableCustomProperties === undefined) {
+            this.inspectableCustomProperties = [];
+        }
+        this.inspectableCustomProperties.push(property);
+    }
+    addInspectorProperties() {
+        this.addInspectableCustomProperty({
+            label: "Cfg Class",
+            propertyName: "cfgClassName",
+            type: InspectableType.String,
+        });
+    }
+}

package/dist/scene/SceneCreator.d.ts

@@ -1,7 +1,7 @@
-import { Engine } from "@babylonjs/core/Engines/engine.js";
-import "@babylonjs/core/Materials/Textures/Loaders/envTextureLoader.js";
-import "@babylonjs/core/Misc/dds.js";
-import { Scene } from "@babylonjs/core/scene.js";
-export declare type SceneCreator = (engine: Engine) => Scene;
-export declare function getDefaultScene(engine: Engine, envUrl?: string): Scene;
+import { Engine } from "@babylonjs/core/Engines/engine.js";
+import "@babylonjs/core/Materials/Textures/Loaders/envTextureLoader.js";
+import "@babylonjs/core/Misc/dds.js";
+import { Scene } from "@babylonjs/core/scene.js";
+export declare type SceneCreator = (engine: Engine) => Scene;
+export declare function getDefaultScene(engine: Engine, envUrl?: string): Scene;
 //# sourceMappingURL=SceneCreator.d.ts.map

package/dist/scene/SceneCreator.js

@@ -1,22 +1,22 @@
-import { CubeTexture } from "@babylonjs/core/Materials/Textures/cubeTexture.js";
-import "@babylonjs/core/Materials/Textures/Loaders/envTextureLoader.js"; // Needed for environment map
-import { Color4 } from "@babylonjs/core/Maths/math.color.js";
-import "@babylonjs/core/Misc/dds.js"; // Needed for environment map
-import { Scene } from "@babylonjs/core/scene.js";
-const DEFAULT_ENV_URL = "https://catalogueapi-demo.configura.com/envmap/default.env";
-export function getDefaultScene(engine, envUrl) {
-    var scene = new Scene(engine);
-    // If the alpha component of the clearColor is set to 0, then the color components MUST also be
-    // set to 0. Otherwise the color components will sneak into transparent objects in the scene.
-    //
-    // This is because WebGL uses premultiplied alpha colors by default. In premultiplied alpha the
-    // color components have already been multiplied by the alpha value, and "X * 0" is always
-    // zero, no matter what X is. A color like "1, 0, 0, 0" is thus not an valid premultiplied
-    // color and the results is per the WebGL specs undefined.
-    scene.clearColor = new Color4(0, 0, 0, 0).toLinearSpace();
-    var hdrTexture = CubeTexture.CreateFromPrefilteredData(envUrl || DEFAULT_ENV_URL, scene);
-    hdrTexture.gammaSpace = false;
-    scene.environmentTexture = hdrTexture;
-    scene.environmentIntensity = 0.55;
-    return scene;
-}
+import { CubeTexture } from "@babylonjs/core/Materials/Textures/cubeTexture.js";
+import "@babylonjs/core/Materials/Textures/Loaders/envTextureLoader.js"; // Needed for environment map
+import { Color4 } from "@babylonjs/core/Maths/math.color.js";
+import "@babylonjs/core/Misc/dds.js"; // Needed for environment map
+import { Scene } from "@babylonjs/core/scene.js";
+const DEFAULT_ENV_URL = "https://catalogueapi-demo.configura.com/envmap/default.env";
+export function getDefaultScene(engine, envUrl) {
+    var scene = new Scene(engine);
+    // If the alpha component of the clearColor is set to 0, then the color components MUST also be
+    // set to 0. Otherwise the color components will sneak into transparent objects in the scene.
+    //
+    // This is because WebGL uses premultiplied alpha colors by default. In premultiplied alpha the
+    // color components have already been multiplied by the alpha value, and "X * 0" is always
+    // zero, no matter what X is. A color like "1, 0, 0, 0" is thus not an valid premultiplied
+    // color and the results is per the WebGL specs undefined.
+    scene.clearColor = new Color4(0, 0, 0, 0).toLinearSpace();
+    var hdrTexture = CubeTexture.CreateFromPrefilteredData(envUrl || DEFAULT_ENV_URL, scene);
+    hdrTexture.gammaSpace = false;
+    scene.environmentTexture = hdrTexture;
+    scene.environmentIntensity = 0.55;
+    return scene;
+}

package/dist/utilities/CfgBoundingBox.d.ts

@@ -1,17 +1,22 @@
-import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-export declare class CfgBoundingBox {
-    minimum: Vector3;
-    maximum: Vector3;
-    constructor(minimum?: Vector3, maximum?: Vector3);
-    private _isEmpty;
-    reConstruct(minimum: Vector3, maximum: Vector3): CfgBoundingBox;
-    copyFrom(otherBoundingBox: CfgBoundingBox): CfgBoundingBox;
-    clone(): CfgBoundingBox;
-    get center(): Vector3;
-    translate(vec: Vector3): CfgBoundingBox;
-    expand(otherBoundingBox: CfgBoundingBox): CfgBoundingBox;
-    applyMatrix(matrix: Matrix): CfgBoundingBox;
-    get spaceDiagonal(): number;
-    get isEmpty(): boolean;
-}
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+export declare class CfgBoundingBox {
+    minimum: Vector3;
+    maximum: Vector3;
+    constructor(minimum?: Vector3, maximum?: Vector3);
+    /**
+     * Means that the bounding box should be seen as "undefined", which is not the same as "zero"
+     */
+    private _isEmpty;
+    reConstruct(minimum: Vector3, maximum: Vector3): CfgBoundingBox;
+    copyFrom(otherBoundingBox: CfgBoundingBox): CfgBoundingBox;
+    clone(): CfgBoundingBox;
+    get center(): Vector3;
+    translate(vec: Vector3): CfgBoundingBox;
+    expand(otherBoundingBox: CfgBoundingBox): CfgBoundingBox;
+    expandWithPoint(point: Vector3): CfgBoundingBox;
+    applyMatrix(matrix: Matrix): CfgBoundingBox;
+    get spaceDiagonal(): number;
+    get isEmpty(): boolean;
+    get corners(): Vector3[];
+}
 //# sourceMappingURL=CfgBoundingBox.d.ts.map

package/dist/utilities/CfgBoundingBox.js

@@ -1,64 +1,81 @@
-import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-export class CfgBoundingBox {
-    constructor(minimum, maximum) {
-        /// Means that the bounding box should be seen as "undefined", which is not the same as "zero".
-        this._isEmpty = true;
-        this.minimum = (minimum === null || minimum === void 0 ? void 0 : minimum.clone()) || Vector3.Zero();
-        this.maximum = (maximum === null || maximum === void 0 ? void 0 : maximum.clone()) || Vector3.Zero();
-        this._isEmpty = minimum === undefined && maximum === undefined;
-    }
-    reConstruct(minimum, maximum) {
-        this.minimum.copyFrom(minimum);
-        this.maximum.copyFrom(maximum);
-        this._isEmpty = false;
-        return this;
-    }
-    copyFrom(otherBoundingBox) {
-        this.reConstruct(otherBoundingBox.minimum, otherBoundingBox.maximum);
-        this._isEmpty = otherBoundingBox.isEmpty;
-        return this;
-    }
-    clone() {
-        return new CfgBoundingBox(this.minimum, this.maximum);
-    }
-    get center() {
-        return Vector3.Center(this.minimum, this.maximum);
-    }
-    translate(vec) {
-        this.minimum.addInPlace(vec);
-        this.maximum.addInPlace(vec);
-        return this;
-    }
-    expand(otherBoundingBox) {
-        if (otherBoundingBox.isEmpty) {
-            return this;
-        }
-        if (this.isEmpty) {
-            this.reConstruct(otherBoundingBox.minimum, otherBoundingBox.maximum);
-            return this;
-        }
-        this.reConstruct(this.minimum.minimizeInPlace(otherBoundingBox.minimum), this.maximum.maximizeInPlace(otherBoundingBox.maximum));
-        return this;
-    }
-    applyMatrix(matrix) {
-        if (this.isEmpty) {
-            return this;
-        }
-        // Transform can be rotation, in which case we might need to re-minimize/maximize
-        const transformedMin = Vector3.TransformCoordinates(this.minimum, matrix);
-        const transformedMax = Vector3.TransformCoordinates(this.maximum, matrix);
-        this.reConstruct(transformedMin.clone().minimizeInPlace(transformedMax), transformedMax.maximizeInPlace(transformedMin));
-        return this;
-    }
-    get spaceDiagonal() {
-        if (this.isEmpty) {
-            return 0;
-        }
-        const minimum = this.minimum.asArray();
-        const maximum = this.maximum.asArray();
-        return Math.sqrt(minimum.reduce((a, c, i) => a + Math.pow(maximum[i] - c, 2)));
-    }
-    get isEmpty() {
-        return this._isEmpty;
-    }
-}
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+export class CfgBoundingBox {
+    constructor(minimum, maximum) {
+        /**
+         * Means that the bounding box should be seen as "undefined", which is not the same as "zero"
+         */
+        this._isEmpty = true;
+        this.minimum = (minimum === null || minimum === void 0 ? void 0 : minimum.clone()) || Vector3.Zero();
+        this.maximum = (maximum === null || maximum === void 0 ? void 0 : maximum.clone()) || Vector3.Zero();
+        this._isEmpty = minimum === undefined && maximum === undefined;
+    }
+    reConstruct(minimum, maximum) {
+        this.minimum.copyFrom(minimum);
+        this.maximum.copyFrom(maximum);
+        this._isEmpty = false;
+        return this;
+    }
+    copyFrom(otherBoundingBox) {
+        this.reConstruct(otherBoundingBox.minimum, otherBoundingBox.maximum);
+        this._isEmpty = otherBoundingBox.isEmpty;
+        return this;
+    }
+    clone() {
+        return new CfgBoundingBox(this.minimum, this.maximum);
+    }
+    get center() {
+        return Vector3.Center(this.minimum, this.maximum);
+    }
+    translate(vec) {
+        this.minimum.addInPlace(vec);
+        this.maximum.addInPlace(vec);
+        return this;
+    }
+    expand(otherBoundingBox) {
+        if (otherBoundingBox.isEmpty) {
+            return this;
+        }
+        if (this.isEmpty) {
+            this.reConstruct(otherBoundingBox.minimum, otherBoundingBox.maximum);
+            return this;
+        }
+        this.reConstruct(this.minimum.minimizeInPlace(otherBoundingBox.minimum), this.maximum.maximizeInPlace(otherBoundingBox.maximum));
+        return this;
+    }
+    expandWithPoint(point) {
+        if (this.isEmpty) {
+            this.reConstruct(point, point);
+            return this;
+        }
+        this.reConstruct(this.minimum.minimizeInPlace(point), this.maximum.maximizeInPlace(point));
+        return this;
+    }
+    applyMatrix(matrix) {
+        if (this.isEmpty) {
+            return this;
+        }
+        // Transform can be rotation, in which case we might need to re-minimize/maximize
+        const transformedMin = Vector3.TransformCoordinates(this.minimum, matrix);
+        const transformedMax = Vector3.TransformCoordinates(this.maximum, matrix);
+        this.reConstruct(transformedMin.clone().minimizeInPlace(transformedMax), transformedMax.maximizeInPlace(transformedMin));
+        return this;
+    }
+    get spaceDiagonal() {
+        if (this.isEmpty) {
+            return 0;
+        }
+        const minimum = this.minimum.asArray();
+        const maximum = this.maximum.asArray();
+        return Math.sqrt(minimum.reduce((a, c, i) => a + Math.pow(maximum[i] - c, 2)));
+    }
+    get isEmpty() {
+        return this._isEmpty;
+    }
+    get corners() {
+        const corners = [];
+        for (let a = 0; a < 8; a++) {
+            corners.push(new Vector3(((a & 1) === 0 ? this.minimum : this.maximum).x, ((a & 2) === 0 ? this.minimum : this.maximum).y, ((a & 4) === 0 ? this.minimum : this.maximum).z));
+        }
+        return corners;
+    }
+}

package/dist/utilities/anchor/anchor.d.ts

@@ -0,0 +1,52 @@
+import { Matrix, Vector3 } from "@babylonjs/core";
+import { MeasureParam } from "@configura/web-api";
+import { CfgMeasureDefinition, CfgMeasurePriority } from "@configura/web-api/dist/CfgMeasure";
+import { CfgProductNode } from "../../nodes/CfgProductNode.js";
+import { CfgSymRootNode } from "../../nodes/CfgSymRootNode.js";
+export declare type CfgAnchorTargetNode = CfgSymRootNode;
+export declare type CfgAnchorableNode = CfgSymRootNode | CfgProductNode;
+export declare function nodeEqualsMeasurePriorityNodeReference(node: CfgAnchorTargetNode, ref: CfgMeasurePriority): boolean;
+/**
+ * The measureParamCode points to Measures inside Models. A Model can be used multiple times in a Product.
+ * More than one Model can use the same measureParamCode. Therefore what Measure an AnchorRef points to
+ * can be ambiguous. To help resolve the ambiguities, an anchorRef can have measurePriorities that
+ * governs which target it prefers to be anchored to.
+ *
+ * This method sorts the targets so that the highest priority (lowest index) one is first.
+ * Sorting is done in place on the original array.
+ */
+export declare const getAnchorTargetPriorityComparer: (measureDefinitions: CfgMeasureDefinition[]) => (measureParamCode: string, l: CfgAnchorTargetNode, r: CfgAnchorTargetNode) => number;
+/**
+ * It might be possible in the future to anchor to other things than Measures (which are primarily)
+ * used for stretch, but for now we can only support anchoring to the ends of a Measure.
+ * toSp means anchor to start point, else end point.
+ * The MeasureParam class is used in several different contexts. To make the intent inside Stage
+ * clear CfgAnchorRef exists, which including only what is relevant for when used for anchoring.
+ */
+export declare class CfgAnchorRef {
+    readonly measureParamCode: string;
+    readonly toSp: boolean;
+    static make(m: MeasureParam | undefined): CfgAnchorRef | undefined;
+    private constructor();
+    equal(other: CfgAnchorRef): boolean;
+}
+/** Gets the coordinates of the anchor point relative the anchor target. */
+export declare function getRawAnchorPoint(anchorTarget: CfgAnchorTargetNode | undefined, anchorRef: CfgAnchorRef | undefined): Vector3 | undefined;
+/**
+ * Calculate a matrix which is the translation that makes a point move as if it was a child of
+ * anchorTarget and then moved to the end of the anchorPoint.
+ *
+ * It is assumed that all anchoring happens on symRoot/additionalProduct-level and therefore all anchorees are
+ * siblings to the anchorers.
+ *
+ * Application of anchoring happens from anchor tree root and out, so that originalMatrix of
+ * anchorTarget will already have any anchoring and stretch applied.
+ *
+ * @param ignoreTargetTransformation If true, ignore anchorTarget's originalMatrix. This is a
+ * workaround for that CET (as of this writing) somewhat unexpectedly mostly does not apply the
+ * transformation when anchoring Additional Products. We have noticed some cases when it actually
+ * apply the transform as you would expect. When the bug is solved this should be removed.
+ */
+export declare function getStretchedAnchorPointMatrix(anchorRef: CfgAnchorRef | undefined, anchorTarget: CfgAnchorTargetNode | undefined, ignoreTargetTransformation: boolean): Matrix | undefined;
+export declare function updatedStretchedAnchorPointMatrix(anchorRef: CfgAnchorRef | undefined, anchorTarget: CfgAnchorTargetNode | undefined, currentStretchedAnchorPointMatrix: Matrix | undefined, ignoreTargetTransformation: boolean): Matrix | undefined;
+//# sourceMappingURL=anchor.d.ts.map

package/dist/utilities/anchor/anchor.js

@@ -0,0 +1,136 @@
+import { Matrix, Vector3 } from "@babylonjs/core";
+import { toStretchedPoint } from "../../geometry/stretch/CfgStretchData.js";
+import { identifierIsUri } from "../utilitiesSymRootIdentifier.js";
+/*
+ * MeasurePriorityNodeReferences only uses the url of a Model as identifier. Therefore it
+ * can not differentiate between the same Model/CfgSymRootNode used multiple time in the same
+ * Product. Future development in Catalogues might make this change.
+ */
+export function nodeEqualsMeasurePriorityNodeReference(node, ref) {
+    const nodeIdentifier = node._identifier;
+    // The identifier is made from URL when the node was made from an URL
+    if (!identifierIsUri(nodeIdentifier)) {
+        return false;
+    }
+    // The last segment of the URL is the Windows-style formatted relative file path to the model
+    const pathFromIdentifier = decodeURIComponent(nodeIdentifier.substr(nodeIdentifier.lastIndexOf("/") + 1));
+    return pathFromIdentifier === ref.modelLocalFilePath;
+}
+/**
+ * The measureParamCode points to Measures inside Models. A Model can be used multiple times in a Product.
+ * More than one Model can use the same measureParamCode. Therefore what Measure an AnchorRef points to
+ * can be ambiguous. To help resolve the ambiguities, an anchorRef can have measurePriorities that
+ * governs which target it prefers to be anchored to.
+ *
+ * This method sorts the targets so that the highest priority (lowest index) one is first.
+ * Sorting is done in place on the original array.
+ */
+export const getAnchorTargetPriorityComparer = (measureDefinitions) => (measureParamCode, l, r) => {
+    const measureDefinition = measureDefinitions.find((m) => m.measureParamCode === measureParamCode);
+    if (measureDefinition === undefined) {
+        return 0;
+    }
+    const measurePriorities = measureDefinition.measurePriorities;
+    const lP = measurePriorities.find((m) => nodeEqualsMeasurePriorityNodeReference(l, m));
+    const rP = measurePriorities.find((m) => nodeEqualsMeasurePriorityNodeReference(r, m));
+    const lIndex = lP === undefined ? Number.POSITIVE_INFINITY : lP.index;
+    const rIndex = rP === undefined ? Number.POSITIVE_INFINITY : rP.index;
+    const prioDiff = lIndex - rIndex;
+    if (prioDiff !== 0) {
+        return prioDiff;
+    }
+    return l._identifier.localeCompare(r._identifier);
+};
+/**
+ * It might be possible in the future to anchor to other things than Measures (which are primarily)
+ * used for stretch, but for now we can only support anchoring to the ends of a Measure.
+ * toSp means anchor to start point, else end point.
+ * The MeasureParam class is used in several different contexts. To make the intent inside Stage
+ * clear CfgAnchorRef exists, which including only what is relevant for when used for anchoring.
+ */
+export class CfgAnchorRef {
+    constructor(measureParamCode, toSp) {
+        this.measureParamCode = measureParamCode;
+        this.toSp = toSp;
+    }
+    static make(m) {
+        if (m === undefined) {
+            return undefined;
+        }
+        const { anchorPoint, code } = m;
+        if (anchorPoint === undefined) {
+            console.error("No anchorPoint for measureParam intended to be used as anchorRef");
+            return undefined;
+        }
+        const isSp = anchorPoint === "sp";
+        const isEp = anchorPoint === "ep";
+        if (!isSp && !isEp) {
+            console.error("AnchorPoint is neither sp nor ep");
+            return undefined;
+        }
+        return new CfgAnchorRef(code, isSp);
+    }
+    equal(other) {
+        return this.measureParamCode === other.measureParamCode && this.toSp === other.toSp;
+    }
+}
+/** Gets the coordinates of the anchor point relative the anchor target. */
+export function getRawAnchorPoint(anchorTarget, anchorRef) {
+    if (anchorTarget === undefined) {
+        return undefined;
+    }
+    if (anchorRef === undefined) {
+        throw new Error("AnchorTo not set even though we got an anchorTarget");
+    }
+    const { measureParamCode, toSp } = anchorRef;
+    const { stretchDatas } = anchorTarget;
+    const targetStretchData = stretchDatas.find((stretchData) => measureParamCode === stretchData.measureParam);
+    if (targetStretchData === undefined) {
+        throw new Error("No target stretch data for measureParamCode found");
+    }
+    return toSp ? targetStretchData.sp : targetStretchData.ep;
+}
+/**
+ * Calculate a matrix which is the translation that makes a point move as if it was a child of
+ * anchorTarget and then moved to the end of the anchorPoint.
+ *
+ * It is assumed that all anchoring happens on symRoot/additionalProduct-level and therefore all anchorees are
+ * siblings to the anchorers.
+ *
+ * Application of anchoring happens from anchor tree root and out, so that originalMatrix of
+ * anchorTarget will already have any anchoring and stretch applied.
+ *
+ * @param ignoreTargetTransformation If true, ignore anchorTarget's originalMatrix. This is a
+ * workaround for that CET (as of this writing) somewhat unexpectedly mostly does not apply the
+ * transformation when anchoring Additional Products. We have noticed some cases when it actually
+ * apply the transform as you would expect. When the bug is solved this should be removed.
+ */
+export function getStretchedAnchorPointMatrix(anchorRef, anchorTarget, ignoreTargetTransformation) {
+    const rawAnchorPoint = getRawAnchorPoint(anchorTarget, anchorRef);
+    if (rawAnchorPoint === undefined || anchorTarget === undefined) {
+        return undefined;
+    }
+    // Apply current stretch to the anchor point
+    const stretchedAnchorPoint = toStretchedPoint(rawAnchorPoint, anchorTarget.stretchDatas, anchorTarget.cfgProductNode.product.configuration._internal
+        .stretchReferenceLengthsByMeasureParamCode);
+    // Sometimes, apply the anchorTarget matrix, as if the point was a child to the anchorTarget.
+    const anchorTargetMatrixApplied = ignoreTargetTransformation
+        ? stretchedAnchorPoint
+        : Vector3.TransformCoordinates(stretchedAnchorPoint, anchorTarget.originalMatrix);
+    // We use translation as when we anchor things we do not change their orientation,
+    // we only move them to snap to this point
+    return Matrix.Identity().setTranslation(anchorTargetMatrixApplied);
+}
+export function updatedStretchedAnchorPointMatrix(anchorRef, anchorTarget, currentStretchedAnchorPointMatrix, ignoreTargetTransformation) {
+    const stretchedAnchorPointMatrix = getStretchedAnchorPointMatrix(anchorRef, anchorTarget, ignoreTargetTransformation);
+    if (currentStretchedAnchorPointMatrix === undefined &&
+        stretchedAnchorPointMatrix === undefined) {
+        return undefined;
+    }
+    if (currentStretchedAnchorPointMatrix !== undefined &&
+        stretchedAnchorPointMatrix !== undefined &&
+        stretchedAnchorPointMatrix.equals(currentStretchedAnchorPointMatrix)) {
+        return undefined;
+    }
+    return stretchedAnchorPointMatrix;
+}

package/dist/utilities/anchor/anchorMap.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Returns a map from child to parent guaranteed to be loop free.
+ * The anchor children (keys in the map) will all have a "anchorRef" and there is what
+ * measureParam they are linked on is found.
+ * Sorted so that parents are always before their children
+ * This function is a bit of a "best effort". These things are not well defined in CET - you
+ * can anchor A on B and B on A at the same time for example. You can also anchor B to A
+ * while there exists multiple A:s. The code below is a naive implementation as in it will
+ * not make the solution which allows the most things to be linked. But that is fine as you
+ * should never create a catalogue with strange anchoring anyhow.
+ */
+export declare function makeAnchoredToAnchorMap<A extends {
+    anchorRef: {
+        measureParamCode: string;
+    } | undefined;
+}, T extends {
+    stretchDatas: {
+        measureParam: string;
+    }[];
+}>(nodes: (A | T)[], targetCandidateComparer: (measureParamCode: string, l: T, r: T) => number): Map<A, T>;
+//# sourceMappingURL=anchorMap.d.ts.map