brep-io-kernel 1.0.17 → 1.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brep-io-kernel",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "scripts": {
     "dev": "pnpm generateLicenses && pnpm build:kernel && vite --host 0.0.0.0",
     "build": "pnpm generateLicenses && vite build",

package/src/FeatureRegistry.js

@@ -134,6 +134,9 @@ export class FeatureRegistry {
     if (!FeatureClass.longName) {
       FeatureClass.longName = FeatureClass.featureName || FeatureClass.name || FeatureClass.shortName || 'Feature';
     }
+    if (typeof FeatureClass.showContexButton !== 'function') {
+      FeatureClass.showContexButton = () => false;
+    }
     this.features.push(FeatureClass);
   }
 

package/src/PartHistory.js

@@ -341,6 +341,7 @@ export class PartHistory {
       if (JSON.stringify(feature.inputParams) !== feature.lastRunInputParams) feature.dirty = true;
 
       instance.inputParams = await this.sanitizeInputParams(FeatureClass.inputParamsSchema, feature.inputParams);
+      try { this._captureReferencePreviewSnapshots(feature, FeatureClass.inputParamsSchema, instance.inputParams, instance.persistentData); } catch { }
       // check the timestamps of any objects referenced by reference_selection inputs; if any are newer than the feature timestamp, mark dirty
       for (const key in FeatureClass.inputParamsSchema) {
         if (Object.prototype.hasOwnProperty.call(FeatureClass.inputParamsSchema, key)) {
@@ -460,6 +461,146 @@ export class PartHistory {
     return this;
   }
 
+  _captureReferencePreviewSnapshots(feature, schema, resolvedParams, persistentTarget = null) {
+    if (!schema || !resolvedParams) return;
+    const stores = [];
+    if (feature) {
+      feature.persistentData = feature.persistentData || {};
+      stores.push(feature.persistentData);
+    }
+    if (persistentTarget && typeof persistentTarget === 'object') {
+      stores.push(persistentTarget);
+    }
+    if (!stores.length) return;
+    const ensureBucket = (store, key) => {
+      if (!store.__refPreviewSnapshots || typeof store.__refPreviewSnapshots !== 'object') {
+        store.__refPreviewSnapshots = {};
+      }
+      if (!store.__refPreviewSnapshots[key] || typeof store.__refPreviewSnapshots[key] !== 'object') {
+        store.__refPreviewSnapshots[key] = {};
+      }
+      return store.__refPreviewSnapshots[key];
+    };
+
+    const normalizeRefName = (obj) => {
+      if (!obj) return null;
+      const raw = obj.name != null ? String(obj.name).trim() : '';
+      if (raw) return raw;
+      const type = obj.type || 'OBJECT';
+      const pos = obj.position || {};
+      const x = Number.isFinite(pos.x) ? pos.x : 0;
+      const y = Number.isFinite(pos.y) ? pos.y : 0;
+      const z = Number.isFinite(pos.z) ? pos.z : 0;
+      return `${type}(${x},${y},${z})`;
+    };
+
+    const extractEdgeWorldPositions = (obj) => {
+      if (!obj) return [];
+      try { obj.updateMatrixWorld?.(true); } catch { }
+      try {
+        if (typeof obj.points === 'function') {
+          const pts = obj.points(true);
+          if (Array.isArray(pts) && pts.length) {
+            const flat = [];
+            for (const p of pts) {
+              if (!p) continue;
+              const x = Number(p.x);
+              const y = Number(p.y);
+              const z = Number(p.z);
+              if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) continue;
+              flat.push(x, y, z);
+            }
+            if (flat.length >= 6) return flat;
+          }
+        }
+      } catch { /* ignore */ }
+
+      try {
+        const geom = obj.geometry;
+        const pos = geom && typeof geom.getAttribute === 'function' ? geom.getAttribute('position') : null;
+        if (!pos || pos.itemSize !== 3 || pos.count < 2) return [];
+        const tmp = new THREE.Vector3();
+        const flat = [];
+        for (let i = 0; i < pos.count; i++) {
+          tmp.set(pos.getX(i), pos.getY(i), pos.getZ(i));
+          tmp.applyMatrix4(obj.matrixWorld);
+          flat.push(tmp.x, tmp.y, tmp.z);
+        }
+        return flat.length >= 6 ? flat : [];
+      } catch { /* ignore */ }
+      return [];
+    };
+
+    const extractFaceEdgePositions = (face) => {
+      if (!face) return [];
+      const out = [];
+      const addEdge = (edge) => {
+        const positions = extractEdgeWorldPositions(edge);
+        if (positions && positions.length >= 6) out.push(positions);
+      };
+
+      if (Array.isArray(face.edges) && face.edges.length) {
+        for (const edge of face.edges) addEdge(edge);
+        return out;
+      }
+
+      const faceName = face?.name || face?.userData?.faceName || null;
+      const parentSolid = face?.parentSolid || face?.userData?.parentSolid || face?.parent || null;
+      if (!faceName || !parentSolid || !Array.isArray(parentSolid.children)) return out;
+      for (const child of parentSolid.children) {
+        if (!child || child.type !== SelectionFilter.EDGE) continue;
+        const faceA = child?.userData?.faceA || null;
+        const faceB = child?.userData?.faceB || null;
+        if (faceA === faceName || faceB === faceName) {
+          addEdge(child);
+        }
+      }
+      return out;
+    };
+
+    for (const key in schema) {
+      if (!Object.prototype.hasOwnProperty.call(schema, key)) continue;
+      const def = schema[key];
+      if (!def || def.type !== 'reference_selection') continue;
+      const selected = Array.isArray(resolvedParams[key]) ? resolvedParams[key] : [];
+      if (!selected.length) continue;
+      const buckets = stores.map((store) => ensureBucket(store, key));
+      for (const obj of selected) {
+        if (!obj || typeof obj !== 'object') continue;
+        const refName = normalizeRefName(obj);
+        if (!refName) continue;
+        const objType = String(obj.type || '').toUpperCase();
+        const sourceUuid = obj.uuid || null;
+        const sourceFeatureId = obj.owningFeatureID ?? null;
+        if (objType === SelectionFilter.EDGE || objType === 'EDGE') {
+          const positions = extractEdgeWorldPositions(obj);
+          if (positions && positions.length >= 6) {
+            for (const bucket of buckets) {
+              bucket[refName] = { type: 'EDGE', positions, sourceUuid, sourceFeatureId };
+            }
+          }
+        } else if (objType === SelectionFilter.FACE || objType === 'FACE' || objType === SelectionFilter.PLANE || objType === 'PLANE') {
+          const edgePositions = extractFaceEdgePositions(obj);
+          if (edgePositions && edgePositions.length) {
+            const snapType = (objType === SelectionFilter.PLANE || objType === 'PLANE') ? 'PLANE' : 'FACE';
+            for (const bucket of buckets) {
+              bucket[refName] = { type: snapType, edgePositions, sourceUuid, sourceFeatureId };
+            }
+          }
+        } else if (objType === SelectionFilter.VERTEX || objType === 'VERTEX') {
+          const pos = new THREE.Vector3();
+          try {
+            if (typeof obj.getWorldPosition === 'function') obj.getWorldPosition(pos);
+            else pos.set(obj.position?.x || 0, obj.position?.y || 0, obj.position?.z || 0);
+          } catch { }
+          for (const bucket of buckets) {
+            bucket[refName] = { type: 'VERTEX', position: [pos.x, pos.y, pos.z], sourceUuid, sourceFeatureId };
+          }
+        }
+      }
+    }
+  }
+
 
   async _coerceRunEffects(result, featureType, featureID) {
     if (result == null) return { added: [], removed: [] };

package/src/UI/CADmaterials.js

@@ -127,8 +127,8 @@ export const CADmaterials = {
             depthWrite: true,
             // Keep selected faces slightly behind edges as well.
             polygonOffset: true,
-            polygonOffsetFactor: 0,
-            polygonOffsetUnits: 0,
+            polygonOffsetFactor: -2,
+            polygonOffsetUnits: 1,
             emissiveIntensity: 0,
         })
     },

package/src/UI/MainToolbar.js

@@ -79,6 +79,14 @@ export class MainToolbar {
         color: #e9f0ff;
         box-shadow: 0 0 0 1px rgba(110,168,254,.2) inset;
       }
+      .mtb-selection {
+        display: none;
+        align-items: center;
+        gap: 6px;
+        padding-left: 6px;
+        margin-left: 2px;
+        border-left: 1px solid #364053;
+      }
     `;
     document.head.appendChild(style);
   }
@@ -103,7 +111,8 @@ export class MainToolbar {
     b.className = 'mtb-btn';
     b.textContent = label;
     b.title = title || label;
-    b.addEventListener('click', (e) => { e.stopPropagation(); try { onClick && onClick(); } catch {} });
+    b.__mtbOnClick = onClick;
+    b.addEventListener('click', (e) => { e.stopPropagation(); try { b.__mtbOnClick && b.__mtbOnClick(); } catch {} });
     return b;
   }
 
@@ -111,11 +120,39 @@ export class MainToolbar {
   addCustomButton({ label, title, onClick }) {
     try {
       const btn = this._btn(String(label ?? '🔧'), String(title || ''), onClick);
-      this._left?.appendChild(btn);
+      const anchor = this._selectionContainer && this._selectionContainer.parentNode === this._left
+        ? this._selectionContainer
+        : null;
+      if (anchor) this._left?.insertBefore(btn, anchor);
+      else this._left?.appendChild(btn);
       return btn;
     } catch { return null; }
   }
 
+  _ensureSelectionContainer() {
+    if (this._selectionContainer) return this._selectionContainer;
+    const wrap = document.createElement('div');
+    wrap.className = 'mtb-selection';
+    this._selectionContainer = wrap;
+    this._left?.appendChild(wrap);
+    return wrap;
+  }
+
+  // Public: allow selection-based buttons in their own cluster
+  addSelectionButton({ label, title, onClick }) {
+    try {
+      const btn = this._btn(String(label ?? '🔧'), String(title || ''), onClick);
+      if (label && String(label).length <= 2) btn.classList.add('mtb-icon');
+      const wrap = this._ensureSelectionContainer();
+      wrap.appendChild(btn);
+      return btn;
+    } catch { return null; }
+  }
+
+  getSelectionContainer() {
+    return this._ensureSelectionContainer();
+  }
+
   _positionWithSidebar() {
     try {
       const sb = this.viewer?.sidebar;