@configura/babylon-view 2.1.0-alpha.0 → 2.1.0-alpha.1

package/dist/utilities/anchor/anchor.js

@@ -1,133 +1,133 @@
-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 DtoMeasureParam 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 {
-    /**
-     * The name stretchSymNodeId might seem confusing. And it is. Turns out CET is implemented so
-     * that it bases its anchoring on symNode Id containing the stretch. Not the measureParamId.
-     */
-    constructor(stretchSymNodeId, toSp) {
-        this.stretchSymNodeId = stretchSymNodeId;
-        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.stretchSymNodeId === other.stretchSymNodeId && 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 { stretchSymNodeId, toSp } = anchorRef;
-    const { stretchDatas } = anchorTarget;
-    const targetStretchData = stretchDatas.find((stretchData) => stretchSymNodeId === stretchData.stretchSymNodeId);
-    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.
- */
-export function getStretchedAnchorPointMatrix(anchorRef, anchorTarget) {
-    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 = 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) {
-    const stretchedAnchorPointMatrix = getStretchedAnchorPointMatrix(anchorRef, anchorTarget);
-    if (currentStretchedAnchorPointMatrix === undefined &&
-        stretchedAnchorPointMatrix === undefined) {
-        return undefined;
-    }
-    if (currentStretchedAnchorPointMatrix !== undefined &&
-        stretchedAnchorPointMatrix !== undefined &&
-        stretchedAnchorPointMatrix.equals(currentStretchedAnchorPointMatrix)) {
-        return undefined;
-    }
-    return stretchedAnchorPointMatrix;
-}
+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 DtoMeasureParam 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 {
+    /**
+     * The name stretchSymNodeId might seem confusing. And it is. Turns out CET is implemented so
+     * that it bases its anchoring on symNode Id containing the stretch. Not the measureParamId.
+     */
+    constructor(stretchSymNodeId, toSp) {
+        this.stretchSymNodeId = stretchSymNodeId;
+        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.stretchSymNodeId === other.stretchSymNodeId && 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 { stretchSymNodeId, toSp } = anchorRef;
+    const { stretchDatas } = anchorTarget;
+    const targetStretchData = stretchDatas.find((stretchData) => stretchSymNodeId === stretchData.stretchSymNodeId);
+    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.
+ */
+export function getStretchedAnchorPointMatrix(anchorRef, anchorTarget) {
+    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 = 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) {
+    const stretchedAnchorPointMatrix = getStretchedAnchorPointMatrix(anchorRef, anchorTarget);
+    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

@@ -1,21 +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: {
-        stretchSymNodeId: string;
-    } | undefined;
-}, T extends {
-    stretchDatas: {
-        stretchSymNodeId: string;
-    }[];
-}>(nodes: (A | T)[], targetCandidateComparer: (measureParamCode: string, l: T, r: T) => number): Map<A, T>;
+/**
+ * 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: {
+        stretchSymNodeId: string;
+    } | undefined;
+}, T extends {
+    stretchDatas: {
+        stretchSymNodeId: string;
+    }[];
+}>(nodes: (A | T)[], targetCandidateComparer: (measureParamCode: string, l: T, r: T) => number): Map<A, T>;
 //# sourceMappingURL=anchorMap.d.ts.map

package/dist/utilities/anchor/anchorMap.js

@@ -1,111 +1,111 @@
-// Tests do not work if we have Babylon-imports in the same file, so this has to be a separate file
-/**
- * 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 function makeAnchoredToAnchorMap(nodes, targetCandidateComparer) {
-    function isAnchoree(n) {
-        return "anchorRef" in n;
-    }
-    function isTarget(n) {
-        return "stretchDatas" in n;
-    }
-    const anchoredToAnchorMap = new Map();
-    // Step 1: build a legal tree
-    for (const node of nodes) {
-        if (!isAnchoree(node)) {
-            continue;
-        }
-        const anchorRef = node.anchorRef;
-        if (anchorRef === undefined) {
-            continue;
-        }
-        const stretchSymNodeId = anchorRef.stretchSymNodeId;
-        const targetCandidates = nodes
-            .filter((n) => {
-            // Ignore self
-            if (node === n) {
-                return false;
-            }
-            if (!isTarget(n)) {
-                return false;
-            }
-            // Can we anchor to this node?
-            return n.stretchDatas.some((stretchData) => stretchSymNodeId === stretchData.stretchSymNodeId);
-        })
-            .map((t, i) => ({ t, i }))
-            .sort((l, r) => {
-            // As sort is not stable in JS-versions older than EcmaScript 2019 we add the
-            // array original index to have as a fallback when there is a draw
-            const comp = targetCandidateComparer(anchorRef.stretchSymNodeId, l.t, r.t);
-            if (comp === 0) {
-                return l.i - r.i;
-            }
-            return comp;
-        })
-            .map((tt) => tt.t);
-        let okay = true;
-        for (const otherNode of targetCandidates) {
-            okay = true;
-            // Loop control, the candidate can not be a child, then we would get a loop
-            let loopCandidate = otherNode;
-            while (loopCandidate !== undefined) {
-                if (!isAnchoree(loopCandidate)) {
-                    break;
-                }
-                loopCandidate = anchoredToAnchorMap.get(loopCandidate);
-                if (loopCandidate === node) {
-                    okay = false;
-                    break;
-                }
-            }
-            if (okay) {
-                anchoredToAnchorMap.set(node, otherNode);
-                break;
-            }
-        }
-        if (!okay) {
-            console.warn("No SymRootNode to anchor to found.");
-        }
-    }
-    // From anchored to anchor
-    const unplaced = Array.from(anchoredToAnchorMap);
-    // Step 2: Build a sorted map so that parents are before their children
-    const result = [];
-    for (;;) {
-        const candidate = unplaced.pop();
-        if (candidate === undefined) {
-            //done
-            break;
-        }
-        const parent = candidate[1];
-        const indexInResult = result.findIndex((otherAnchoredToAnchor) => parent === otherAnchoredToAnchor[0]);
-        if (indexInResult === -1) {
-            // Candidates parent is not in the result, see if it in those waiting
-            const indexInUnplaced = unplaced.findIndex((item) => item[0] === parent);
-            if (indexInUnplaced === -1) {
-                // The parent was not part of the original nodes, so we just add this node.
-                result.push(candidate);
-            }
-            else {
-                const toMoveUp = unplaced.splice(indexInUnplaced, 1)[0];
-                // Put back to candidate
-                unplaced.push(candidate);
-                // Move up the parent
-                unplaced.push(toMoveUp);
-            }
-        }
-        else {
-            // Parent is in result
-            result.splice(indexInResult + 1, 0, candidate);
-        }
-    }
-    return new Map(result);
-}
+// Tests do not work if we have Babylon-imports in the same file, so this has to be a separate file
+/**
+ * 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 function makeAnchoredToAnchorMap(nodes, targetCandidateComparer) {
+    function isAnchoree(n) {
+        return "anchorRef" in n;
+    }
+    function isTarget(n) {
+        return "stretchDatas" in n;
+    }
+    const anchoredToAnchorMap = new Map();
+    // Step 1: build a legal tree
+    for (const node of nodes) {
+        if (!isAnchoree(node)) {
+            continue;
+        }
+        const anchorRef = node.anchorRef;
+        if (anchorRef === undefined) {
+            continue;
+        }
+        const stretchSymNodeId = anchorRef.stretchSymNodeId;
+        const targetCandidates = nodes
+            .filter((n) => {
+            // Ignore self
+            if (node === n) {
+                return false;
+            }
+            if (!isTarget(n)) {
+                return false;
+            }
+            // Can we anchor to this node?
+            return n.stretchDatas.some((stretchData) => stretchSymNodeId === stretchData.stretchSymNodeId);
+        })
+            .map((t, i) => ({ t, i }))
+            .sort((l, r) => {
+            // As sort is not stable in JS-versions older than EcmaScript 2019 we add the
+            // array original index to have as a fallback when there is a draw
+            const comp = targetCandidateComparer(anchorRef.stretchSymNodeId, l.t, r.t);
+            if (comp === 0) {
+                return l.i - r.i;
+            }
+            return comp;
+        })
+            .map((tt) => tt.t);
+        let okay = true;
+        for (const otherNode of targetCandidates) {
+            okay = true;
+            // Loop control, the candidate can not be a child, then we would get a loop
+            let loopCandidate = otherNode;
+            while (loopCandidate !== undefined) {
+                if (!isAnchoree(loopCandidate)) {
+                    break;
+                }
+                loopCandidate = anchoredToAnchorMap.get(loopCandidate);
+                if (loopCandidate === node) {
+                    okay = false;
+                    break;
+                }
+            }
+            if (okay) {
+                anchoredToAnchorMap.set(node, otherNode);
+                break;
+            }
+        }
+        if (!okay) {
+            console.warn("No SymRootNode to anchor to found.");
+        }
+    }
+    // From anchored to anchor
+    const unplaced = Array.from(anchoredToAnchorMap);
+    // Step 2: Build a sorted map so that parents are before their children
+    const result = [];
+    for (;;) {
+        const candidate = unplaced.pop();
+        if (candidate === undefined) {
+            //done
+            break;
+        }
+        const parent = candidate[1];
+        const indexInResult = result.findIndex((otherAnchoredToAnchor) => parent === otherAnchoredToAnchor[0]);
+        if (indexInResult === -1) {
+            // Candidates parent is not in the result, see if it in those waiting
+            const indexInUnplaced = unplaced.findIndex((item) => item[0] === parent);
+            if (indexInUnplaced === -1) {
+                // The parent was not part of the original nodes, so we just add this node.
+                result.push(candidate);
+            }
+            else {
+                const toMoveUp = unplaced.splice(indexInUnplaced, 1)[0];
+                // Put back to candidate
+                unplaced.push(candidate);
+                // Move up the parent
+                unplaced.push(toMoveUp);
+            }
+        }
+        else {
+            // Parent is in result
+            result.splice(indexInResult + 1, 0, candidate);
+        }
+    }
+    return new Map(result);
+}