brep-io-kernel 1.0.17 → 1.0.19

package/src/UI/history/HistoryCollectionWidget.js

@@ -1,4 +1,5 @@
 import { SchemaForm } from '../featureDialogs.js';
+import { SelectionFilter } from '../SelectionFilter.js';
 import { resolveEntryId, resolveHistoryDisplayInfo } from './historyDisplayInfo.js';
 import { HISTORY_COLLECTION_WIDGET_CSS } from './historyCollectionWidget.css.js';
 
@@ -43,6 +44,8 @@ export class HistoryCollectionWidget {
     this._addMenu = null;
     this._onGlobalClick = null;
     this._globalRefreshHandler = null;
+    this._contextSuppressKey = `hc-${Math.random().toString(36).slice(2, 9)}`;
+    this._contextSuppressActive = false;
 
     this.uiElement = document.createElement('div');
     this.uiElement.className = 'history-collection-widget-host';
@@ -100,6 +103,7 @@ export class HistoryCollectionWidget {
   }
 
   dispose() {
+    this._setContextSuppression(false);
     if (typeof this._listenerUnsub === 'function') {
       try { this._listenerUnsub(); } catch (_) {}
     }
@@ -152,6 +156,7 @@ export class HistoryCollectionWidget {
     this._listEl.textContent = '';
 
     if (!entries.length) {
+      this._setContextSuppression(false);
       const empty = document.createElement('div');
       empty.className = 'hc-empty';
       empty.textContent = 'No entries yet.';
@@ -185,6 +190,7 @@ export class HistoryCollectionWidget {
       targetId = null;
     }
     this._expandedId = targetId;
+    this._setContextSuppression(!!this._expandedId);
 
     for (let i = 0; i < entries.length; i++) {
       const entry = entries[i];
@@ -589,12 +595,24 @@ export class HistoryCollectionWidget {
   }
 
   _notifyEntryToggle(entry, isOpen) {
+    this._setContextSuppression(!!isOpen);
     if (!this._onEntryToggle) return;
     try {
       this._onEntryToggle(entry || null, isOpen);
     } catch (_) { /* ignore toggle hook errors */ }
   }
 
+  _setContextSuppression(isOpen) {
+    const next = !!isOpen;
+    if (this._contextSuppressActive === next) return;
+    this._contextSuppressActive = next;
+    if (SelectionFilter && typeof SelectionFilter.setContextBarSuppressed === 'function') {
+      try {
+        SelectionFilter.setContextBarSuppressed(this._contextSuppressKey, next);
+      } catch (_) { /* ignore */ }
+    }
+  }
+
   async _moveEntry(id, delta) {
     if (!id) return;
     const entries = this._getEntries();
@@ -659,7 +677,7 @@ export class HistoryCollectionWidget {
       this.render();
       this._emitCollectionChange('add', entry);
       this._deferScrollToEntry(createdEntryId);
-      return;
+      return entry;
     }
     const entry = await this._instantiateEntryForType(typeStr);
     if (!entry) return;
@@ -680,6 +698,7 @@ export class HistoryCollectionWidget {
     this.render();
     this._emitCollectionChange('add', entry);
     this._deferScrollToEntry(createdEntryId);
+    return entry;
   }
 
   _handleSchemaChange(id, entry, details) {

package/src/UI/pmi/AnnotationRegistry.js

@@ -29,6 +29,9 @@ class AnnotationRegistry {
       if (!ctor.longName) {
         ctor.longName = ctor.featureName || ctor.name || ctor.shortName || ctor.type || 'Annotation';
       }
+      if (typeof ctor.showContexButton !== 'function') {
+        ctor.showContexButton = () => false;
+      }
     }
     const typeKey = normalizeKey(
       handler.type

package/src/UI/toolbarButtons/orientToFaceButton.js

@@ -92,7 +92,10 @@ function _orientCameraToFace(viewer, face) {
   try { if (controls?.target) controls.target.copy(target); } catch {}
   try { if (controls?._gizmos?.position) controls._gizmos.position.copy(target); } catch {}
   try { controls?.update?.(); } catch {}
+  try { controls?._gizmos?.updateMatrix?.(); } catch {}
+  try { controls?._gizmos?.updateMatrixWorld?.(true); } catch {}
   try { controls?.updateMatrixState?.(); } catch {}
+  try { controls?.saveState?.(); } catch {}
   try { viewer.render?.(); } catch {}
 
   return true;

package/src/UI/toolbarButtons/registerDefaultButtons.js

@@ -4,10 +4,7 @@
 import { createSaveButton } from './saveButton.js';
 import { createUndoButton, createRedoButton } from './undoRedoButtons.js';
 import { createZoomToFitButton } from './zoomToFitButton.js';
-import { createOrientToFaceButton } from './orientToFaceButton.js';
 import { createWireframeToggleButton } from './wireframeToggleButton.js';
-import { createInspectorToggleButton } from './inspectorToggleButton.js';
-import { createMetadataButton } from './metadataButton.js';
 import { createImportButton } from './importButton.js';
 import { createExportButton } from './exportButton.js';
 import { createFlatPatternButton } from './flatPatternButton.js';
@@ -21,10 +18,7 @@ export function registerDefaultToolbarButtons(viewer) {
   const creators = [
     createSaveButton,
     createZoomToFitButton,
-    createOrientToFaceButton,
     createWireframeToggleButton,
-    createInspectorToggleButton,
-    createMetadataButton,
     createImportButton,
     createExportButton,
     createFlatPatternButton,

package/src/UI/toolbarButtons/registerSelectionButtons.js

@@ -0,0 +1,68 @@
+import { SelectionFilter } from '../SelectionFilter.js';
+import { createOrientToFaceButton } from './orientToFaceButton.js';
+import { createInspectorToggleButton } from './inspectorToggleButton.js';
+import { createMetadataButton } from './metadataButton.js';
+
+const hasSelection = (items) => Array.isArray(items) && items.length > 0;
+const hasType = (items, types) => {
+  if (!Array.isArray(items) || items.length === 0) return false;
+  const typeSet = new Set((types || []).map((t) => String(t || '').toUpperCase()));
+  if (typeSet.size === 0) return false;
+  return items.some((obj) => typeSet.has(String(obj?.type || '').toUpperCase()));
+};
+
+export function registerSelectionToolbarButtons(viewer) {
+  if (!viewer || typeof SelectionFilter?.registerSelectionAction !== 'function') return;
+
+
+  try {
+    SelectionFilter.registerSelectionAction({
+      id: 'selection-action-clear',
+      label: '␛',
+      title: 'Clear selection',
+      onClick: () => {
+        const scene = viewer?.partHistory?.scene || viewer?.scene || null;
+        if (scene) SelectionFilter.unselectAll(scene);
+        try { viewer?._hideSelectionOverlay?.(); } catch { }
+      },
+      shouldShow: (selection) => hasSelection(selection),
+    });
+  } catch { }
+
+
+
+  try {
+    const perpSpec = createOrientToFaceButton(viewer);
+    if (perpSpec) {
+      SelectionFilter.registerSelectionAction({
+        id: 'selection-action-perp',
+        ...perpSpec,
+        shouldShow: (selection) => hasType(selection, ['FACE', 'PLANE']),
+      });
+    }
+  } catch { }
+
+  try {
+    const inspectorSpec = createInspectorToggleButton(viewer);
+    if (inspectorSpec) {
+      SelectionFilter.registerSelectionAction({
+        id: 'selection-action-inspector',
+        ...inspectorSpec,
+        shouldShow: (selection) => hasSelection(selection),
+      });
+    }
+  } catch { }
+
+
+
+  try {
+    const metadataSpec = createMetadataButton(viewer);
+    if (metadataSpec) {
+      SelectionFilter.registerSelectionAction({
+        id: 'selection-action-metadata',
+        ...metadataSpec,
+        shouldShow: (selection) => hasSelection(selection),
+      });
+    }
+  } catch { }
+}

package/src/UI/viewer.js

@@ -20,6 +20,7 @@ import './expressionsManager.js'
 import { expressionsManager } from './expressionsManager.js';
 import { MainToolbar } from './MainToolbar.js';
 import { registerDefaultToolbarButtons } from './toolbarButtons/registerDefaultButtons.js';
+import { registerSelectionToolbarButtons } from './toolbarButtons/registerSelectionButtons.js';
 import { FileManagerWidget } from './fileManagerWidget.js';
 import './mobile.js';
 import { SketchMode3D } from './sketcher/SketchMode3D.js';
@@ -1239,6 +1240,9 @@ export class Viewer {
         this.mainToolbar = new MainToolbar(this);
         // Register core/default toolbar buttons via the public API
         try { registerDefaultToolbarButtons(this); } catch { }
+        // Register selection-context toolbar buttons (shown based on selection)
+        try { registerSelectionToolbarButtons(this); } catch { }
+        try { SelectionFilter.refreshSelectionActions?.(); } catch { }
         // Drain any queued custom toolbar buttons from early plugin registration
         try {
             const q = Array.isArray(this._pendingToolbarButtons) ? this._pendingToolbarButtons : [];
@@ -3471,15 +3475,29 @@ export class Viewer {
     // Inspector panel (toggle + update-on-click)
     // ----------------------------------------
     toggleInspectorPanel() { this._inspectorOpen ? this._closeInspectorPanel() : this._openInspectorPanel(); }
+    _getInspectorSelectionTarget() {
+        const last = this._lastInspectorTarget;
+        if (last && last.selected) return last;
+        const scene = this.partHistory?.scene || this.scene || null;
+        if (!scene || typeof scene.traverse !== 'function') return null;
+        let found = null;
+        scene.traverse((obj) => {
+            if (found || !obj || !obj.selected) return;
+            found = obj;
+        });
+        return found;
+    }
     _openInspectorPanel() {
         if (this._inspectorOpen) return;
         this._ensureInspectorPanel();
         this._inspectorEl.style.display = 'flex';
         this._inspectorOpen = true;
-        // Placeholder message until user clicks an object
-        try {
-            this._setInspectorPlaceholder('Click an object in the scene to inspect.');
-        } catch { }
+        const target = this._getInspectorSelectionTarget();
+        if (target) {
+            try { this._updateInspectorFor(target); } catch { }
+            return;
+        }
+        try { this._setInspectorPlaceholder('Click an object in the scene to inspect.'); } catch { }
     }
     _closeInspectorPanel() {
         if (!this._inspectorOpen) return;

package/src/assemblyConstraints/AssemblyConstraintRegistry.js

@@ -54,6 +54,9 @@ export class AssemblyConstraintRegistry {
     if (!ConstraintClass.longName) {
       ConstraintClass.longName = ConstraintClass.constraintName || ConstraintClass.name || ConstraintClass.shortName || 'Constraint';
     }
+    if (typeof ConstraintClass.showContexButton !== 'function') {
+      ConstraintClass.showContexButton = () => false;
+    }
     const keys = this.#collectKeys(ConstraintClass);
     if (!keys.typeKey) return;
 

package/src/features/boolean/BooleanFeature.js

@@ -25,6 +25,21 @@ export class BooleanFeature {
     static shortName = "B";
     static longName = "Boolean";
     static inputParamsSchema = inputParamsSchema;
+    static showContexButton(selectedItems) {
+        const items = Array.isArray(selectedItems) ? selectedItems : [];
+        const solids = items
+            .filter((it) => String(it?.type || '').toUpperCase() === 'SOLID')
+            .map((it) => it?.name)
+            .filter((name) => !!name);
+        if (solids.length < 2) return false;
+        const [targetSolid, ...tools] = solids;
+        return {
+            params: {
+                targetSolid,
+                boolean: { operation: 'UNION', targets: tools },
+            },
+        };
+    }
 
     constructor() {
         this.inputParams = {};

package/src/features/chamfer/ChamferFeature.js

@@ -46,6 +46,18 @@ export class ChamferFeature {
     static shortName = "CH";
     static longName = "Chamfer";
     static inputParamsSchema = inputParamsSchema;
+    static showContexButton(selectedItems) {
+        const items = Array.isArray(selectedItems) ? selectedItems : [];
+        const edges = items
+            .filter((it) => {
+                const type = String(it?.type || '').toUpperCase();
+                return type === 'EDGE' || type === 'FACE';
+            })
+            .map((it) => it?.name || it?.userData?.edgeName || it?.userData?.faceName)
+            .filter((name) => !!name);
+        if (!edges.length) return false;
+        return { params: { edges } };
+    }
 
     constructor() {
         this.inputParams = {};

package/src/features/extrude/ExtrudeFeature.js

@@ -41,6 +41,17 @@ export class ExtrudeFeature {
   static shortName = "E";
   static longName = "Extrude";
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const items = Array.isArray(selectedItems) ? selectedItems : [];
+    const pick = items.find((it) => {
+      const type = String(it?.type || '').toUpperCase();
+      return type === 'FACE' || type === 'SKETCH';
+    });
+    if (!pick) return false;
+    const name = pick?.name || pick?.userData?.faceName || pick?.userData?.edgeName || null;
+    if (!name) return false;
+    return { field: 'profile', value: name };
+  }
 
   constructor() {
     this.inputParams = {};

package/src/features/fillet/FilletFeature.js

@@ -63,6 +63,18 @@ export class FilletFeature {
     static shortName = "F";
     static longName = "Fillet";
     static inputParamsSchema = inputParamsSchema;
+    static showContexButton(selectedItems) {
+        const items = Array.isArray(selectedItems) ? selectedItems : [];
+        const edges = items
+            .filter((it) => {
+                const type = String(it?.type || '').toUpperCase();
+                return type === 'EDGE' || type === 'FACE';
+            })
+            .map((it) => it?.name || it?.userData?.edgeName || it?.userData?.faceName)
+            .filter((name) => !!name);
+        if (!edges.length) return false;
+        return { params: { edges } };
+    }
 
     constructor() {
         this.inputParams = {};

package/src/features/hole/HoleFeature.js

@@ -569,6 +569,21 @@ export class HoleFeature {
   static shortName = 'H';
   static longName = 'Hole';
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const items = Array.isArray(selectedItems) ? selectedItems : [];
+    const sketch = items.find((it) => {
+      const type = String(it?.type || '').toUpperCase();
+      if (type === 'SKETCH') return true;
+      if (it?.parent && String(it.parent.type || '').toUpperCase() === 'SKETCH') return true;
+      return false;
+    });
+    if (!sketch) return false;
+    const name = (String(sketch?.type || '').toUpperCase() === 'SKETCH')
+      ? sketch.name
+      : sketch.parent?.name;
+    if (!name) return false;
+    return { field: 'face', value: name };
+  }
 
   constructor() {
     this.inputParams = {};

package/src/features/loft/LoftFeature.js

@@ -58,6 +58,23 @@ export class LoftFeature {
   static shortName = "LOFT";
   static longName = "Loft";
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const items = Array.isArray(selectedItems) ? selectedItems : [];
+    const profiles = items
+      .filter((it) => {
+        const type = String(it?.type || '').toUpperCase();
+        return type === 'FACE' || type === 'SKETCH';
+      })
+      .map((it) => {
+        if (!it) return null;
+        if (String(it.type || '').toUpperCase() === 'SKETCH') return it.name || null;
+        if (it.parent && String(it.parent.type || '').toUpperCase() === 'SKETCH') return it.parent.name || null;
+        return it.name || it.userData?.faceName || null;
+      })
+      .filter((name) => !!name);
+    if (profiles.length < 2) return false;
+    return { params: { profiles } };
+  }
 
   constructor() {
     this.inputParams = {};

package/src/features/mirror/MirrorFeature.js

@@ -35,6 +35,20 @@ export class MirrorFeature {
     static longName = "Mirror";
 
     static inputParamsSchema = inputParamsSchema;
+    static showContexButton(selectedItems) {
+        const items = Array.isArray(selectedItems) ? selectedItems : [];
+        const solids = items
+            .filter((it) => String(it?.type || '').toUpperCase() === 'SOLID')
+            .map((it) => it?.name)
+            .filter((name) => !!name);
+        const plane = items.find((it) => {
+            const type = String(it?.type || '').toUpperCase();
+            return type === 'FACE' || type === 'PLANE';
+        });
+        const planeName = plane?.name || plane?.userData?.faceName || null;
+        if (!solids.length || !planeName) return false;
+        return { params: { solids, mirrorPlane: planeName } };
+    }
 
     constructor() {
         this.inputParams = {};

package/src/features/patternLinear/PatternLinearFeature.js

@@ -34,6 +34,15 @@ export class PatternLinearFeature {
   static shortName = "PATLIN";
   static longName = "Pattern Linear";
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const items = Array.isArray(selectedItems) ? selectedItems : [];
+    const solids = items
+      .filter((it) => String(it?.type || '').toUpperCase() === 'SOLID')
+      .map((it) => it?.name)
+      .filter((name) => !!name);
+    if (!solids.length) return false;
+    return { params: { solids } };
+  }
 
   constructor() {
     this.inputParams = {};

package/src/features/patternRadial/PatternRadialFeature.js

@@ -49,6 +49,19 @@ export class PatternRadialFeature {
   static shortName = "PATRAD";
   static longName = "Pattern Radial";
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const items = Array.isArray(selectedItems) ? selectedItems : [];
+    const solids = items
+      .filter((it) => String(it?.type || '').toUpperCase() === 'SOLID')
+      .map((it) => it?.name)
+      .filter((name) => !!name);
+    if (!solids.length) return false;
+    const axis = items.find((it) => String(it?.type || '').toUpperCase() === 'EDGE');
+    const axisName = axis?.name || axis?.userData?.edgeName || null;
+    const params = { solids };
+    if (axisName) params.axisRef = axisName;
+    return { params };
+  }
 
   constructor() {
     this.inputParams = {};

package/src/features/plane/PlaneFeature.js

@@ -46,6 +46,16 @@ export class PlaneFeature {
     static shortName = "P";
     static longName = "Plane";
     static inputParamsSchema = inputParamsSchema;
+    static showContexButton(selectedItems) {
+        const items = Array.isArray(selectedItems) ? selectedItems : [];
+        const ref = items.find((it) => {
+            const type = String(it?.type || '').toUpperCase();
+            return type === 'FACE' || type === 'PLANE';
+        });
+        const name = ref?.name || ref?.userData?.faceName || null;
+        if (!name) return false;
+        return { field: 'datum', value: name };
+    }
 
     constructor() {
         this.inputParams = {};

package/src/features/revolve/RevolveFeature.js

@@ -47,6 +47,21 @@ export class RevolveFeature {
     static shortName = "R";
     static longName = "Revolve";
     static inputParamsSchema = inputParamsSchema;
+    static showContexButton(selectedItems) {
+        const items = Array.isArray(selectedItems) ? selectedItems : [];
+        const profileObj = items.find((it) => {
+            const type = String(it?.type || '').toUpperCase();
+            return type === 'FACE' || type === 'SKETCH';
+        });
+        if (!profileObj) return false;
+        const profileName = profileObj?.name || profileObj?.userData?.faceName || null;
+        if (!profileName) return false;
+        const axisObj = items.find((it) => String(it?.type || '').toUpperCase() === 'EDGE');
+        const axisName = axisObj?.name || axisObj?.userData?.edgeName || null;
+        const params = { profile: profileName };
+        if (axisName) params.axis = axisName;
+        return { params };
+    }
 
     constructor() {
         this.inputParams = {};

package/src/features/sketch/SketchFeature.js

@@ -82,6 +82,17 @@ export class SketchFeature {
     static shortName = "S";
     static longName = "Sketch";
     static inputParamsSchema = inputParamsSchema;
+    static showContexButton(selectedItems) {
+        const items = Array.isArray(selectedItems) ? selectedItems : [];
+        const target = items.find((it) => {
+            const type = String(it?.type || '').toUpperCase();
+            return type === 'FACE' || type === 'PLANE';
+        });
+        if (!target) return false;
+        const name = target?.name || target?.userData?.faceName || null;
+        if (!name) return false;
+        return { field: 'sketchPlane', value: name };
+    }
 
     constructor() {
         this.inputParams = {};

package/src/features/sweep/SweepFeature.js

@@ -48,6 +48,23 @@ export class SweepFeature {
   static shortName = "SW";
   static longName = "Sweep";
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const items = Array.isArray(selectedItems) ? selectedItems : [];
+    const profileObj = items.find((it) => {
+      const type = String(it?.type || '').toUpperCase();
+      return type === 'FACE' || type === 'SKETCH';
+    });
+    if (!profileObj) return false;
+    const profileName = profileObj?.name || profileObj?.userData?.faceName || null;
+    if (!profileName) return false;
+    const edges = items
+      .filter((it) => String(it?.type || '').toUpperCase() === 'EDGE')
+      .map((it) => it?.name || it?.userData?.edgeName)
+      .filter((name) => !!name);
+    const params = { profile: profileName };
+    if (edges.length) params.path = edges;
+    return { params };
+  }
 
   constructor() {
     this.inputParams = {};

package/src/features/transform/TransformFeature.js

@@ -57,6 +57,18 @@ export class TransformFeature {
   static shortName = "XFORM";
   static longName = "Transform";
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const items = Array.isArray(selectedItems) ? selectedItems : [];
+    const solids = items
+      .filter((it) => {
+        const type = String(it?.type || '').toUpperCase();
+        return type === 'SOLID';
+      })
+      .map((it) => it?.name)
+      .filter((name) => !!name);
+    if (!solids.length) return false;
+    return { params: { solids } };
+  }
 
   constructor() {
     this.inputParams = {};

package/src/features/tube/TubeFeature.js

@@ -332,6 +332,18 @@ export class TubeFeature {
   static shortName = 'TU';
   static longName = 'Tube';
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const items = Array.isArray(selectedItems) ? selectedItems : [];
+    if (items.some((it) => String(it?.type || '').toUpperCase() !== 'EDGE')) {
+      return false;
+    }
+    const edges = items
+      .filter((it) => String(it?.type || '').toUpperCase() === 'EDGE')
+      .map((it) => it?.name || it?.userData?.edgeName)
+      .filter((name) => !!name);
+    if (!edges.length) return false;
+    return { params: { path: edges } };
+  }
 
   constructor() {
     this.inputParams = {};