brep-io-kernel 1.0.20 → 1.0.22

package/src/UI/toolbarButtons/selectionStateButton.js

@@ -0,0 +1,206 @@
+import { FloatingWindow } from '../FloatingWindow.js';
+import { SelectionFilter } from '../SelectionFilter.js';
+
+const PANEL_KEY = '__selectionStatePanel';
+
+function _ensureStyles() {
+  if (document.getElementById('selection-state-styles')) return;
+  const style = document.createElement('style');
+  style.id = 'selection-state-styles';
+  style.textContent = `
+    .selection-state-content {
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+      padding: 10px;
+      height: 100%;
+      box-sizing: border-box;
+      color: #e5e7eb;
+      font-size: 12px;
+    }
+    .selection-state-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 8px;
+      font-weight: 700;
+    }
+    .selection-state-count {
+      color: #cbd5f5;
+      font-size: 12px;
+    }
+    .selection-state-list {
+      flex: 1 1 auto;
+      min-height: 0;
+      overflow: auto;
+      background: rgba(8,10,14,.55);
+      border: 1px solid #1f2937;
+      border-radius: 8px;
+      padding: 8px;
+      display: flex;
+      flex-direction: column;
+      gap: 6px;
+    }
+    .selection-state-item {
+      display: grid;
+      grid-template-columns: auto 1fr;
+      gap: 6px 10px;
+      align-items: center;
+      padding: 4px 6px;
+      border-radius: 6px;
+      background: rgba(255,255,255,.02);
+      border: 1px solid rgba(148,163,184,.18);
+    }
+    .selection-state-type {
+      font-size: 10px;
+      font-weight: 700;
+      letter-spacing: 0.04em;
+      text-transform: uppercase;
+      color: #9aa0aa;
+    }
+    .selection-state-name {
+      font-size: 12px;
+      color: #e5e7eb;
+      word-break: break-word;
+    }
+    .selection-state-empty {
+      color: #9aa0aa;
+      font-style: italic;
+      padding: 6px;
+    }
+  `;
+  document.head.appendChild(style);
+}
+
+function _labelFor(obj) {
+  if (!obj) return 'Unknown';
+  const name = obj.name
+    || obj.userData?.faceName
+    || obj.userData?.edgeName
+    || obj.userData?.vertexName
+    || obj.userData?.solidName
+    || obj.userData?.name
+    || null;
+  return name || '(unnamed)';
+}
+
+class SelectionStatePanel {
+  constructor(viewer) {
+    this.viewer = viewer || null;
+    this.window = null;
+    this.root = null;
+    this.content = null;
+    this.countEl = null;
+    this.listEl = null;
+    this._boundSelectionChanged = this._handleSelectionChanged.bind(this);
+    try { window.addEventListener('selection-changed', this._boundSelectionChanged); } catch { }
+  }
+
+  toggle() {
+    if (this.root && this.root.style.display !== 'none') this.close();
+    else this.open();
+  }
+
+  open() {
+    this._ensureWindow();
+    if (!this.root) return;
+    this.root.style.display = 'flex';
+    this._render();
+  }
+
+  close() {
+    if (this.root) {
+      try { this.root.style.display = 'none'; } catch { }
+    }
+  }
+
+  _ensureWindow() {
+    if (this.window && this.root) return;
+    _ensureStyles();
+    const fw = new FloatingWindow({
+      title: 'Selection State',
+      width: 360,
+      height: 320,
+      right: 14,
+      top: 120,
+      shaded: false,
+      onClose: () => this.close(),
+    });
+
+    const content = document.createElement('div');
+    content.className = 'selection-state-content';
+
+    const header = document.createElement('div');
+    header.className = 'selection-state-header';
+    const title = document.createElement('div');
+    title.textContent = 'Currently selected';
+    const count = document.createElement('div');
+    count.className = 'selection-state-count';
+    header.appendChild(title);
+    header.appendChild(count);
+
+    const list = document.createElement('div');
+    list.className = 'selection-state-list';
+
+    content.appendChild(header);
+    content.appendChild(list);
+    fw.content.appendChild(content);
+
+    this.window = fw;
+    this.root = fw.root;
+    this.content = content;
+    this.countEl = count;
+    this.listEl = list;
+  }
+
+  _handleSelectionChanged() {
+    if (!this.root || this.root.style.display === 'none') return;
+    this._render();
+  }
+
+  _render() {
+    const list = this.listEl;
+    const countEl = this.countEl;
+    if (!list || !countEl) return;
+
+    const scene = this.viewer?.partHistory?.scene || this.viewer?.scene || null;
+    const selection = SelectionFilter.getSelectedObjects({ scene }) || [];
+    countEl.textContent = `${selection.length} selected`;
+
+    list.textContent = '';
+    if (!selection.length) {
+      const empty = document.createElement('div');
+      empty.className = 'selection-state-empty';
+      empty.textContent = 'No items selected.';
+      list.appendChild(empty);
+      return;
+    }
+
+    for (const obj of selection) {
+      const row = document.createElement('div');
+      row.className = 'selection-state-item';
+      const type = document.createElement('div');
+      type.className = 'selection-state-type';
+      type.textContent = String(obj?.type || 'object').toUpperCase();
+      const name = document.createElement('div');
+      name.className = 'selection-state-name';
+      name.textContent = _labelFor(obj);
+      row.appendChild(type);
+      row.appendChild(name);
+      list.appendChild(row);
+    }
+  }
+}
+
+export function createSelectionStateButton(viewer) {
+  if (!viewer) return null;
+  if (!viewer[PANEL_KEY]) {
+    viewer[PANEL_KEY] = new SelectionStatePanel(viewer);
+  }
+  const panel = viewer[PANEL_KEY];
+  return {
+    label: 'Sel',
+    title: 'Toggle selection state window',
+    onClick: () => panel.toggle(),
+  };
+}

package/src/UI/viewer.js

@@ -16,6 +16,7 @@ import { HistoryWidget } from './HistoryWidget.js';
 import { AssemblyConstraintsWidget } from './assembly/AssemblyConstraintsWidget.js';
 import { PartHistory } from '../PartHistory.js';
 import { SelectionFilter } from './SelectionFilter.js';
+import { SelectionState } from './SelectionState.js';
 import './expressionsManager.js'
 import { expressionsManager } from './expressionsManager.js';
 import { MainToolbar } from './MainToolbar.js';
@@ -533,6 +534,8 @@ export class Viewer {
         this._attachRendererEvents(el);
 
         SelectionFilter.viewer = this;
+        try { SelectionFilter.startClickWatcher(this); } catch (_) { }
+        try { SelectionFilter._ensureSelectionFilterIndicator?.(this); } catch (_) { }
         // Use capture on pointerup to ensure we end interactions even if pointerup fires off-element
         window.addEventListener('pointerup', this._onPointerUp, { passive: false, capture: true });
         document.addEventListener('dblclick', this._onGlobalDoubleClick, { passive: false, capture: true });
@@ -1476,8 +1479,15 @@ export class Viewer {
     // ----------------------------------------
     // PMI Edit Mode API
     // ----------------------------------------
+    _collapseExpandedDialogsForModeSwitch() {
+        try { this.historyWidget?.collapseExpandedEntries?.({ clearOpenState: true, notify: false }); } catch { }
+        try { this.assemblyConstraintsWidget?.collapseExpandedDialogs?.(); } catch { }
+        try { this._pmiMode?.collapseExpandedDialogs?.(); } catch { }
+    }
+
     startPMIMode(viewEntry, viewIndex, widget = this.pmiViewsWidget) {
         const alreadyActive = !!this._pmiMode;
+        try { this._collapseExpandedDialogsForModeSwitch(); } catch { }
         if (!alreadyActive) {
             try { this.assemblyConstraintsWidget?.onPMIModeEnter?.(); } catch { }
         }
@@ -1506,6 +1516,9 @@ export class Viewer {
 
     endPMIMode() {
         const hadMode = !!this._pmiMode;
+        if (hadMode) {
+            try { this._collapseExpandedDialogsForModeSwitch(); } catch { }
+        }
         try { if (this._pmiMode) this._pmiMode.dispose(); } catch { }
         this._pmiMode = null;
         if (hadMode) {
@@ -2174,16 +2187,8 @@ export class Viewer {
             const ud = obj.userData;
             const defaultMaterial = ud.__defaultMaterial ?? baseMaterial;
             if (!ud.__defaultMaterial) ud.__defaultMaterial = baseMaterial;
-            const isHovered = !!ud.__hoverMatApplied;
-            const isSelected = obj.selected === true;
-
             const applyBase = (mat) => {
-                ud.__baseMaterial = mat;
-                if (isHovered) {
-                    ud.__hoverOrigMat = mat;
-                } else if (!isSelected && mat) {
-                    obj.material = mat;
-                }
+                SelectionState.setBaseMaterial(obj, mat);
             };
 
             if (!color) {
@@ -2365,21 +2370,25 @@ export class Viewer {
 
         // Prefer the intersected object if it is clickable
         let obj = intersection.object;
+        if (obj && obj.type === 'POINTS' && obj.parent && String(obj.parent.type || '').toUpperCase() === SelectionFilter.VERTEX) {
+            obj = obj.parent;
+        }
 
         // If the object (or its ancestors) doesn't expose onClick, climb to one that does
         let target = obj;
         while (target && typeof target.onClick !== 'function' && target.visible) target = target.parent;
+        if (!target) target = obj;
         if (!target) return null;
 
         // Respect selection filter: ensure target is a permitted type, or ALL
         if (typeof isAllowed === 'function') {
             // Allow selecting already-selected items regardless (toggle off), consistent with SceneListing
             if (!isAllowed(target.type) && !target.selected) {
-                // Try to find a closer ancestor/descendant of allowed type that is clickable
+                // Try to find a closer ancestor of allowed type
                 // Ascend first (e.g., FACE hit while EDGE is active should try parent SOLID only if allowed)
                 let t = target.parent;
-                while (t && typeof t.onClick === 'function' && !isAllowed(t.type)) t = t.parent;
-                if (t && typeof t.onClick === 'function' && isAllowed(t.type)) target = t;
+                while (t && !isAllowed(t.type)) t = t.parent;
+                if (t && isAllowed(t.type)) target = t;
                 else return null;
             }
         }
@@ -2566,11 +2575,23 @@ export class Viewer {
             SelectionFilter.EDGE,
             SelectionFilter.FACE,
             SelectionFilter.PLANE,
+            SelectionFilter.SKETCH,
+            SelectionFilter.DATUM,
+            SelectionFilter.HELIX,
+            SelectionFilter.LOOP,
             SelectionFilter.SOLID,
             SelectionFilter.COMPONENT,
         ].map(t => normType(t));
+        const normSolid = normType(SelectionFilter.SOLID);
+        const normComponent = normType(SelectionFilter.COMPONENT);
+        const nonSolidAllowed = Array.from(allowedSet).some(t => t && t !== normSolid && t !== normComponent);
         const getPriority = (type) => {
-            const idx = priorityOrder.indexOf(normType(type));
+            const nt = normType(type);
+            if (nonSolidAllowed && (nt === normSolid || nt === normComponent)) {
+                // Always push SOLID/COMPONENT to the end when any other type is allowed.
+                return priorityOrder.length + 2;
+            }
+            const idx = priorityOrder.indexOf(nt);
             return idx === -1 ? priorityOrder.length : idx;
         };
         const isAllowedType = (type) => {

package/src/assemblyConstraints/AssemblyConstraintHistory.js

@@ -3,6 +3,7 @@ import { AssemblyConstraintRegistry } from './AssemblyConstraintRegistry.js';
 import { evaluateConstraintNumericValue } from './constraintExpressionUtils.js';
 import { deepClone } from '../utils/deepClone.js';
 import { normalizeTypeString } from '../utils/normalizeTypeString.js';
+import { resolveSelectionObject } from '../utils/selectionResolver.js';
 
 const RESERVED_KEYS = new Set(['type', 'persistentData', '__open']);
 
@@ -102,47 +103,6 @@ function removeExistingDebugArrows(scene) {
   }
 }
 
-function resolveSelectionObject(scene, selection) {
-  if (!scene || selection == null) return null;
-  let target = selection;
-  if (Array.isArray(selection)) {
-    target = selection.find((item) => item != null) ?? null;
-  }
-  if (!target) return null;
-  if (target.isObject3D) return target;
-  try {
-    if (typeof target === 'string') {
-      if (typeof scene.traverse === 'function') {
-        let best = null;
-        scene.traverse((obj) => {
-          if (!obj || obj.name !== target) return;
-          if (!best) best = obj;
-          const component = resolveComponentFromObject(obj);
-          const bestComponent = best ? resolveComponentFromObject(best) : null;
-          if (component && !bestComponent) {
-            best = obj;
-          }
-        });
-        if (best) return best;
-      }
-      return typeof scene.getObjectByName === 'function'
-        ? scene.getObjectByName(target)
-        : null;
-    }
-    if (typeof target?.uuid === 'string' && typeof scene.getObjectByProperty === 'function') {
-      const found = scene.getObjectByProperty('uuid', target.uuid);
-      if (found) return found;
-    }
-    if (typeof target?.name === 'string' && typeof scene.getObjectByName === 'function') {
-      const found = scene.getObjectByName(target.name);
-      if (found) return found;
-    }
-  } catch {
-    return null;
-  }
-  return null;
-}
-
 function resolveComponentFromObject(obj) {
   let current = obj;
   while (current) {
@@ -152,6 +112,10 @@ function resolveComponentFromObject(obj) {
   return null;
 }
 
+function scoreObjectForComponent(object) {
+  return resolveComponentFromObject(object) ? 1 : 0;
+}
+
 function vectorFrom(value) {
   if (!value) return null;
   if (value instanceof THREE.Vector3) return value.clone();
@@ -894,7 +858,19 @@ export class AssemblyConstraintHistory {
 
     const updatedComponents = new Set();
 
-    const resolveObject = (selection) => resolveSelectionObject(scene, selection);
+    const resolveObject = (selection) => resolveSelectionObject(scene, selection, {
+      scoreFn: scoreObjectForComponent,
+      allowJson: false,
+      allowUuidString: false,
+      allowUuidObject: true,
+      allowFuzzyName: false,
+      allowNameContains: false,
+      allowPath: false,
+      allowReference: false,
+      allowTarget: false,
+      allowSelectionName: false,
+      arrayMode: 'first',
+    });
     const resolveComponent = (selection) => {
       const obj = resolveObject(selection);
       return resolveComponentFromObject(obj);

package/src/assemblyConstraints/constraints/AngleConstraint.js

@@ -33,6 +33,7 @@ export class AngleConstraint extends BaseAssemblyConstraint {
   static shortName = '∠';
   static longName = '∠ Angle Constraint';
   static constraintType = 'angle';
+  static focusField = 'angle';
   static aliases = ['angle', 'angle_between', 'angular', 'ANGL'];
   static inputParamsSchema = inputParamsSchema;
 

package/src/assemblyConstraints/constraints/DistanceConstraint.js

@@ -37,6 +37,7 @@ export class DistanceConstraint extends BaseAssemblyConstraint {
   static shortName = '⟺';
   static longName = '⟺ Distance Constraint';
   static constraintType = 'distance';
+  static focusField = 'distance';
   static aliases = ['distance', 'offset', 'gap', 'DIST'];
   static inputParamsSchema = inputParamsSchema;
 

package/src/features/selectionUtils.js

@@ -1,16 +1,32 @@
+import { resolveSelectionObject as resolveSelectionObjectBase } from '../utils/selectionResolver.js';
+
 export function resolveSelectionObject(selection, partHistory) {
   if (!selection) return null;
-  if (typeof selection === 'string') {
+  if (typeof selection !== 'string') return selection;
+
+  const nameResolver = (name) => {
     if (partHistory && typeof partHistory.getObjectByName === 'function') {
-      return partHistory.getObjectByName(selection);
+      return partHistory.getObjectByName(name);
     }
     const scene = partHistory?.scene;
     if (scene && typeof scene.getObjectByName === 'function') {
-      return scene.getObjectByName(selection);
+      return scene.getObjectByName(name);
     }
     return null;
-  }
-  return selection;
+  };
+
+  return resolveSelectionObjectBase(partHistory?.scene || null, selection, {
+    nameResolver,
+    allowJson: false,
+    allowUuid: false,
+    allowFuzzyName: false,
+    allowNameContains: false,
+    allowPath: false,
+    allowReference: false,
+    allowTarget: false,
+    allowSelectionName: false,
+    arrayMode: 'first',
+  });
 }
 
 function getFeatureEntryId(entry) {

package/src/features/sketch/SketchFeature.js

@@ -4,6 +4,7 @@ import { BREP } from "../../BREP/BREP.js";
 const THREE = BREP.THREE;
 import { LineGeometry } from 'three/examples/jsm/Addons.js';
 import { deepClone } from '../../utils/deepClone.js';
+import { SelectionState } from '../../UI/SelectionState.js';
 
 const inputParamsSchema = {
     id: {
@@ -892,8 +893,7 @@ export class SketchFeature {
                     if (sketchMat) {
                         sketchMat.side = THREE.DoubleSide;
                         sketchMat.needsUpdate = true;
-                        face.material = sketchMat;
-                        face.userData.__baseMaterial = sketchMat;
+                        SelectionState.setBaseMaterial(face, sketchMat);
                     }
                 } catch { }
                 sceneGroup.add(face);

package/src/features/sketch/sketchSolver2D/constraintDefinitions.js

@@ -689,9 +689,10 @@ const shortestAngleDelta = (target, current) => {
 
 
 export const constraints = {
-    tolerance,
+    get tolerance() { return tolerance; },
+    set tolerance(value) { tolerance = value; },
     constraintFunctions,
-}
+};