brep-io-kernel 1.0.20 → 1.0.22

package/src/UI/pmi/AnnotationCollectionWidget.js

@@ -53,6 +53,7 @@ export class AnnotationCollectionWidget extends HistoryCollectionWidget {
     });
 
     this.pmimode = pmimode || null;
+    this._autoFocusOnExpand = true;
   }
 
   #applyEntryChange({ entry, details }) {

package/src/UI/pmi/BaseAnnotation.js

@@ -15,6 +15,43 @@ export class BaseAnnotation extends ListEntityBase {
     this.resultArtifacts = [];
   }
 
+  static _normalizeSelectionItems(selectedItems) {
+    return Array.isArray(selectedItems) ? selectedItems : [];
+  }
+
+  static _normalizeSelectionType(type) {
+    return String(type || '').toUpperCase();
+  }
+
+  static _isSelectionType(item, allowed) {
+    if (!allowed || !allowed.size) return true;
+    return allowed.has(BaseAnnotation._normalizeSelectionType(item?.type));
+  }
+
+  static _selectionRefName(item) {
+    return item?.name
+      || item?.userData?.faceName
+      || item?.userData?.edgeName
+      || item?.userData?.vertexName
+      || item?.userData?.solidName
+      || item?.userData?.name
+      || null;
+  }
+
+  static _collectSelectionRefs(selectedItems, types = null) {
+    const items = BaseAnnotation._normalizeSelectionItems(selectedItems);
+    const allowed = Array.isArray(types)
+      ? new Set(types.map((t) => BaseAnnotation._normalizeSelectionType(t)))
+      : null;
+    const refs = [];
+    for (const item of items) {
+      if (!BaseAnnotation._isSelectionType(item, allowed)) continue;
+      const ref = BaseAnnotation._selectionRefName(item);
+      if (ref) refs.push(ref);
+    }
+    return refs;
+  }
+
   async run(renderingContext) {
     // Base implementation - subclasses should override
     // renderingContext contains: { pmimode, group, idx, ctx }

package/src/UI/pmi/LabelOverlay.js

@@ -65,6 +65,38 @@ export class LabelOverlay {
           }
         });
       }
+      if (!el.__wheelPassThrough) {
+        const onWheel = (e) => {
+          if (!el.classList.contains('constraint-label')) return;
+          const canvas = this.viewer?.renderer?.domElement;
+          if (!canvas) return;
+          let canceled = false;
+          try {
+            const forwarded = new WheelEvent(e.type, {
+              bubbles: true,
+              cancelable: true,
+              deltaX: e.deltaX,
+              deltaY: e.deltaY,
+              deltaZ: e.deltaZ,
+              deltaMode: e.deltaMode,
+              clientX: e.clientX,
+              clientY: e.clientY,
+              screenX: e.screenX,
+              screenY: e.screenY,
+              ctrlKey: e.ctrlKey,
+              shiftKey: e.shiftKey,
+              altKey: e.altKey,
+              metaKey: e.metaKey,
+            });
+            canceled = !canvas.dispatchEvent(forwarded);
+          } catch { }
+          if (canceled) {
+            try { e.preventDefault(); } catch { }
+          }
+        };
+        el.addEventListener('wheel', onWheel, { passive: false });
+        el.__wheelPassThrough = onWheel;
+      }
       if (this.onDblClick) el.addEventListener('dblclick', (e) => this.onDblClick(idx, ann, e));
       try { this._root.appendChild(el); this._labelMap.set(idx, el); } catch {}
     } else if (text != null) {

package/src/UI/pmi/PMIMode.js

@@ -12,6 +12,7 @@ import { getPMIStyle, setPMIStyle, sanitizePMIStyle } from './pmiStyle.js';
 import { AnnotationHistory } from './AnnotationHistory.js';
 import { LabelOverlay } from './LabelOverlay.js';
 import { AnnotationCollectionWidget } from './AnnotationCollectionWidget.js';
+import { SelectionFilter } from '../SelectionFilter.js';
 import { localStorage as LS } from '../../idbStorage.js';
 
 const cssEscape = (value) => {
@@ -89,6 +90,9 @@ export class PMIMode {
     const v = this.viewer;
     if (!v || !v.container) return;
 
+    // Clear any lingering reference-selection state before PMI interactions.
+    this.#clearActiveReferenceSelection();
+
     // Save and hide existing accordion sections instead of hiding the whole sidebar
     this.#hideOriginalSidebarSections();
 
@@ -168,6 +172,26 @@ export class PMIMode {
     try { if (v.controls) v.controls.enabled = true; } catch { }
   }
 
+  collapseExpandedDialogs() {
+    try { this._annotationWidget?.collapseExpandedEntries?.({ clearOpenState: true }); } catch { /* ignore */ }
+  }
+
+  #clearActiveReferenceSelection() {
+    try {
+      const active = document.querySelectorAll('[active-reference-selection="true"],[active-reference-selection=true]');
+      active.forEach((el) => {
+        try { el.style.filter = 'none'; } catch { }
+        try { el.removeAttribute('active-reference-selection'); } catch { }
+        try {
+          const wrap = el.closest('.ref-single-wrap, .ref-multi-wrap');
+          if (wrap) wrap.classList.remove('ref-active');
+        } catch { }
+      });
+    } catch { }
+    try { if (window.__BREP_activeRefInput) window.__BREP_activeRefInput = null; } catch { }
+    try { SelectionFilter.restoreAllowedSelectionTypes(); } catch { }
+  }
+
   applyViewTransformsSequential() {
     try {
       this.#applyViewTransforms();
@@ -595,6 +619,9 @@ export class PMIMode {
               this.#markAnnotationsDirty();
             },
           });
+          // Avoid auto-activating reference selection on expand; PMI scene clicks should
+          // stay as normal selections unless the user explicitly activates a ref field.
+          this._annotationWidget._autoFocusOnExpand = false;
           widgetWrap.appendChild(this._annotationWidget.uiElement);
 
           this._pmiAnnotationsSection = sec;

package/src/UI/pmi/dimensions/AngleDimensionAnnotation.js

@@ -71,6 +71,11 @@ export class AngleDimensionAnnotation extends BaseAnnotation {
   static longName = 'Angle Dimension';
   static title = 'Angle';
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const refs = BaseAnnotation._collectSelectionRefs(selectedItems, ['FACE', 'EDGE']);
+    if (refs.length < 2) return false;
+    return { params: { targets: refs.slice(0, 2) } };
+  }
 
   constructor(opts = {}) {
     super(opts);

package/src/UI/pmi/dimensions/ExplodeBodyAnnotation.js

@@ -41,6 +41,11 @@ export class ExplodeBodyAnnotation extends BaseAnnotation {
   static title = 'Explode Body';
   static inputParamsSchema = inputParamsSchema;
   static aliases = ['viewTransform'];
+  static showContexButton(selectedItems) {
+    const refs = BaseAnnotation._collectSelectionRefs(selectedItems, ['SOLID']);
+    if (!refs.length) return false;
+    return { params: { targets: refs } };
+  }
 
   constructor(opts = {}) {
     super(opts);

package/src/UI/pmi/dimensions/HoleCalloutAnnotation.js

@@ -71,6 +71,17 @@ export class HoleCalloutAnnotation extends BaseAnnotation {
   static longName = 'Hole Callout';
   static title = 'Hole Callout';
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const items = BaseAnnotation._normalizeSelectionItems(selectedItems);
+    const allowed = new Set(['VERTEX', 'EDGE', 'FACE']);
+    for (const item of items) {
+      if (!BaseAnnotation._isSelectionType(item, allowed)) continue;
+      if (!hasHoleMetadata(item)) continue;
+      const ref = BaseAnnotation._selectionRefName(item);
+      if (ref) return { params: { target: ref } };
+    }
+    return false;
+  }
 
   constructor(opts = {}) {
     super(opts);
@@ -293,6 +304,52 @@ function findHoleDescriptor(partHistory, targetObj, fallbackPoint, targetName =
   return descriptors[0];
 }
 
+function readHoleMetadata(obj) {
+  if (!obj) return null;
+  const ud = obj.userData || null;
+  if (ud?.hole) return ud.hole;
+  if (ud?.metadata?.hole) return ud.metadata.hole;
+  if (typeof obj.getMetadata === 'function') {
+    try {
+      const meta = obj.getMetadata();
+      if (meta?.hole) return meta.hole;
+      if (meta?.metadata?.hole) return meta.metadata.hole;
+    } catch { /* ignore */ }
+  }
+  const faceName = obj?.name || ud?.faceName || null;
+  const parentSolid = obj?.parentSolid || ud?.parentSolid || null;
+  if (faceName && parentSolid && typeof parentSolid.getFaceMetadata === 'function') {
+    try {
+      const meta = parentSolid.getFaceMetadata(faceName);
+      if (meta?.hole) return meta.hole;
+    } catch { /* ignore */ }
+  }
+  return null;
+}
+
+function hasHoleMetadata(target) {
+  if (!target) return false;
+  const queue = [target];
+  const visited = new Set();
+  const hasOwnFaces = (obj) => Object.prototype.hasOwnProperty.call(obj, 'faces');
+  while (queue.length) {
+    const obj = queue.shift();
+    if (!obj || visited.has(obj)) continue;
+    visited.add(obj);
+    if (readHoleMetadata(obj)) return true;
+    if (hasOwnFaces(obj) && Array.isArray(obj.faces)) {
+      for (const face of obj.faces) queue.push(face);
+    } else if (obj.type === 'SOLID' || obj.type === 'COMPONENT') {
+      const kids = Array.isArray(obj.children) ? obj.children : [];
+      for (const child of kids) {
+        if (child && child.type === 'FACE') queue.push(child);
+      }
+    }
+    if (obj.parent) queue.push(obj.parent);
+  }
+  return false;
+}
+
 
 function formatHoleCallout(desc, quantity = 1, options = {}) {
   if (!desc) return '';

package/src/UI/pmi/dimensions/LeaderAnnotation.js

@@ -65,6 +65,11 @@ export class LeaderAnnotation extends BaseAnnotation {
   static longName = 'Leader';
   static title = 'Leader';
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const refs = BaseAnnotation._collectSelectionRefs(selectedItems, ['VERTEX']);
+    if (!refs.length) return false;
+    return { params: { target: refs } };
+  }
 
   constructor(opts = {}) {
     super(opts);

package/src/UI/pmi/dimensions/LinearDimensionAnnotation.js

@@ -9,22 +9,7 @@ const inputParamsSchema = {
     label: 'ID',
     hint: 'unique identifier for the linear dimension',
   },
-  decimals: {
-    type: 'number',
-    default_value: 3,
-    defaultResolver: ({ pmimode }) => {
-      const dec = Number.isFinite(pmimode?._opts?.dimDecimals)
-        ? (pmimode._opts.dimDecimals | 0)
-        : undefined;
-      if (!Number.isFinite(dec)) return undefined;
-      return Math.max(0, Math.min(8, dec));
-    },
-    label: 'Decimals',
-    hint: 'Number of decimal places to display',
-    min: 0,
-    max: 8,
-    step: 1,
-  },
+
   targets: {
     type: 'reference_selection',
     selectionFilter: ['VERTEX', 'EDGE'],
@@ -67,6 +52,22 @@ const inputParamsSchema = {
     label: 'Reference',
     hint: 'Mark as reference dimension (parentheses)',
   },
+  decimals: {
+    type: 'number',
+    default_value: 3,
+    defaultResolver: ({ pmimode }) => {
+      const dec = Number.isFinite(pmimode?._opts?.dimDecimals)
+        ? (pmimode._opts.dimDecimals | 0)
+        : undefined;
+      if (!Number.isFinite(dec)) return undefined;
+      return Math.max(0, Math.min(8, dec));
+    },
+    label: 'Decimals',
+    hint: 'Number of decimal places to display',
+    min: 0,
+    max: 8,
+    step: 1,
+  },
 };
 
 export class LinearDimensionAnnotation extends BaseAnnotation {
@@ -76,6 +77,11 @@ export class LinearDimensionAnnotation extends BaseAnnotation {
   static longName = 'Linear Dimension';
   static title = 'Linear';
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const refs = BaseAnnotation._collectSelectionRefs(selectedItems, ['VERTEX', 'EDGE']);
+    if (!refs.length) return false;
+    return { params: { targets: refs.slice(0, 2) } };
+  }
 
   constructor(opts = {}) {
     super(opts);

package/src/UI/pmi/dimensions/NoteAnnotation.js

@@ -4,6 +4,7 @@
 import * as THREE from 'three';
 import { BaseAnnotation } from '../BaseAnnotation.js';
 import { getPMIStyle } from '../pmiStyle.js';
+import { objectRepresentativePoint } from '../annUtils.js';
 
 const inputParamsSchema = {
   id: {
@@ -34,6 +35,14 @@ export class NoteAnnotation extends BaseAnnotation {
   static longName = 'Note';
   static title = 'Note';
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const items = BaseAnnotation._normalizeSelectionItems(selectedItems);
+    if (!items.length) return false;
+    const anchor = items[0];
+    const point = objectRepresentativePoint(null, anchor);
+    if (!point) return false;
+    return { params: { position: { x: point.x, y: point.y, z: point.z } } };
+  }
 
   constructor(opts = {}) {
     super(opts);

package/src/UI/pmi/dimensions/RadialDimensionAnnotation.js

@@ -9,22 +9,6 @@ const inputParamsSchema = {
     label: 'ID',
     hint: 'unique identifier for the radial dimension',
   },
-  decimals: {
-    type: 'number',
-    default_value: 3,
-    defaultResolver: ({ pmimode }) => {
-      const dec = Number.isFinite(pmimode?._opts?.dimDecimals)
-        ? (pmimode._opts.dimDecimals | 0)
-        : undefined;
-      if (!Number.isFinite(dec)) return undefined;
-      return Math.max(0, Math.min(8, dec));
-    },
-    label: 'Decimals',
-    hint: 'Number of decimal places to display',
-    min: 0,
-    max: 8,
-    step: 1,
-  },
   cylindricalFaceRef: {
     type: 'reference_selection',
     selectionFilter: ['FACE'],
@@ -68,6 +52,22 @@ const inputParamsSchema = {
     label: 'Reference',
     hint: 'Mark as reference dimension (parentheses)',
   },
+  decimals: {
+    type: 'number',
+    default_value: 3,
+    defaultResolver: ({ pmimode }) => {
+      const dec = Number.isFinite(pmimode?._opts?.dimDecimals)
+        ? (pmimode._opts.dimDecimals | 0)
+        : undefined;
+      if (!Number.isFinite(dec)) return undefined;
+      return Math.max(0, Math.min(8, dec));
+    },
+    label: 'Decimals',
+    hint: 'Number of decimal places to display',
+    min: 0,
+    max: 8,
+    step: 1,
+  },
 };
 
 export class RadialDimensionAnnotation extends BaseAnnotation {
@@ -77,6 +77,17 @@ export class RadialDimensionAnnotation extends BaseAnnotation {
   static longName = 'Radial Dimension';
   static title = 'Radial';
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const items = BaseAnnotation._normalizeSelectionItems(selectedItems);
+    const allowed = new Set(['FACE']);
+    for (const item of items) {
+      if (!BaseAnnotation._isSelectionType(item, allowed)) continue;
+      if (!hasCylindricalMetadata(item)) continue;
+      const ref = BaseAnnotation._selectionRefName(item);
+      if (ref) return { params: { cylindricalFaceRef: ref } };
+    }
+    return false;
+  }
 
   constructor(opts = {}) {
     super(opts);
@@ -345,6 +356,60 @@ function computeRadialPoints(pmimode, ann, ctx) {
   }
 }
 
+function isCylindricalMetadata(meta) {
+  if (!meta || typeof meta !== 'object') return false;
+  const type = String(meta.type || '').toLowerCase();
+  if (type === 'cylindrical') {
+    const radius = Number(meta.radius);
+    return Number.isFinite(radius) && radius > 0;
+  }
+  if (type === 'conical') {
+    const r0 = Number(meta.radiusBottom);
+    const r1 = Number(meta.radiusTop);
+    if (!Number.isFinite(r0) || !Number.isFinite(r1)) return false;
+    if (Math.abs(r0 - r1) > 1e-6) return false;
+    return Math.max(r0, r1) > 0;
+  }
+  return false;
+}
+
+function readCylindricalMetadata(obj) {
+  if (!obj) return null;
+  const ud = obj.userData || null;
+  if (ud?.metadata && isCylindricalMetadata(ud.metadata)) return ud.metadata;
+  if (typeof obj.getMetadata === 'function') {
+    try {
+      const meta = obj.getMetadata();
+      if (isCylindricalMetadata(meta)) return meta;
+    } catch { /* ignore */ }
+  }
+  const faceName = obj?.name || ud?.faceName || null;
+  let owner = obj?.parentSolid || ud?.parentSolid || obj?.parent || null;
+  while (owner) {
+    if (faceName && typeof owner.getFaceMetadata === 'function') {
+      try {
+        const meta = owner.getFaceMetadata(faceName);
+        if (isCylindricalMetadata(meta)) return meta;
+      } catch { /* ignore */ }
+      break;
+    }
+    owner = owner.parent || null;
+  }
+  return null;
+}
+
+function hasCylindricalMetadata(target) {
+  if (!target) return false;
+  if (readCylindricalMetadata(target)) return true;
+  if (Array.isArray(target.faces)) {
+    for (const face of target.faces) {
+      if (readCylindricalMetadata(face)) return true;
+    }
+  }
+  if (target.parent && readCylindricalMetadata(target.parent)) return true;
+  return false;
+}
+
 function measureRadialValue(pmimode, ann) {
   try {
     const data = computeRadialPoints(pmimode, ann);

package/src/UI/toolbarButtons/orientToFaceButton.js

@@ -1,4 +1,5 @@
 import * as THREE from 'three';
+import { computeFaceCenter, computeFaceNormal } from '../faceUtils.js';
 
 const FACE_TYPES = new Set(['FACE', 'PLANE']);
 
@@ -26,46 +27,12 @@ function _findSelectedFace(viewer) {
   return found;
 }
 
-function _computeFaceCenter(obj) {
-  if (!obj) return null;
-  try { obj.updateMatrixWorld?.(true); } catch {}
-  try {
-    const box = new THREE.Box3().setFromObject(obj);
-    if (!box.isEmpty()) return box.getCenter(new THREE.Vector3());
-  } catch {}
-  try {
-    const geom = obj.geometry;
-    const bs = geom?.boundingSphere || (geom?.computeBoundingSphere && (geom.computeBoundingSphere(), geom.boundingSphere));
-    if (bs) return obj.localToWorld(bs.center.clone());
-  } catch {}
-  try {
-    return obj.getWorldPosition?.(new THREE.Vector3()) || null;
-  } catch {}
-  return null;
-}
-
-function _computeFaceNormal(obj) {
-  if (!obj) return null;
-  let n = null;
-  if (typeof obj.getAverageNormal === 'function') {
-    try { n = obj.getAverageNormal().clone(); } catch {}
-  }
-  if (!n || n.lengthSq() < 1e-10) {
-    try {
-      const q = obj.getWorldQuaternion?.(new THREE.Quaternion());
-      if (q) n = new THREE.Vector3(0, 0, 1).applyQuaternion(q);
-    } catch {}
-  }
-  if (!n || n.lengthSq() < 1e-10) return null;
-  return n.normalize();
-}
-
 function _orientCameraToFace(viewer, face) {
   const cam = viewer?.camera;
   if (!viewer || !cam || !face) return false;
 
-  const target = _computeFaceCenter(face);
-  const normal = _computeFaceNormal(face);
+  const target = computeFaceCenter(face);
+  const normal = computeFaceNormal(face);
   if (!target || !normal) return false;
 
   const toCam = cam.position.clone().sub(target);

package/src/UI/toolbarButtons/registerDefaultButtons.js

@@ -11,6 +11,7 @@ import { createFlatPatternButton } from './flatPatternButton.js';
 import { createAboutButton } from './aboutButton.js';
 import { createTestsButton } from './testsButton.js';
 import { createScriptRunnerButton } from './scriptRunnerButton.js';
+import { createSelectionStateButton } from './selectionStateButton.js';
 
 export function registerDefaultToolbarButtons(viewer) {
   if (!viewer || typeof viewer.addToolbarButton !== 'function') return;
@@ -25,6 +26,7 @@ export function registerDefaultToolbarButtons(viewer) {
     createAboutButton,
     createTestsButton,
     createScriptRunnerButton,
+    createSelectionStateButton,
     createUndoButton,
     createRedoButton,
   ];