brep-io-kernel 1.0.16 → 1.0.18

package/package.json

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

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,111 @@ 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 [];
+    };
+
+    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.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;

package/src/UI/SelectionFilter.js

@@ -17,6 +17,12 @@ export class SelectionFilter {
     static previouseAllowedSelectionTypes = null;
     static _hovered = new Set(); // objects currently hover-highlighted
     static hoverColor = '#fbff00'; // default hover tint
+    static _selectionActions = new Map();
+    static _selectionActionOrder = [];
+    static _selectionActionSeq = 1;
+    static _selectionActionListenerBound = false;
+    static _selectionActionsPending = false;
+    static _selectionActionBar = null;
 
     constructor() {
         throw new Error("SelectionFilter is static and cannot be instantiated.");
@@ -429,6 +435,11 @@ export class SelectionFilter {
                 if (!targetObj) return false;
 
                 // Update the reference input with the chosen object
+                try {
+                    if (activeRefInput && typeof activeRefInput.__captureReferencePreview === 'function') {
+                        activeRefInput.__captureReferencePreview(targetObj);
+                    }
+                } catch (_) { /* ignore preview capture errors */ }
                 const objType = targetObj.type;
                 const objectName = targetObj.name || `${objType}(${targetObj.position?.x || 0},${targetObj.position?.y || 0},${targetObj.position?.z || 0})`;
 
@@ -617,6 +628,189 @@ export class SelectionFilter {
         } catch (_) { /* noop */ }
     }
 
+    static getSelectedObjects(options = {}) {
+        const scene = options.scene
+            || SelectionFilter.viewer?.partHistory?.scene
+            || SelectionFilter.viewer?.scene
+            || null;
+        const selected = [];
+        if (!scene || typeof scene.traverse !== 'function') return selected;
+        scene.traverse((obj) => {
+            if (obj && obj.selected) selected.push(obj);
+        });
+        return selected;
+    }
+
+    static registerSelectionAction(spec = {}) {
+        if (!spec) return null;
+        const id = String(spec.id || `selection-action-${SelectionFilter._selectionActionSeq++}`);
+        const entry = SelectionFilter._selectionActions.get(id) || { id };
+        entry.label = spec.label ?? entry.label ?? '';
+        entry.title = spec.title ?? entry.title ?? entry.label ?? '';
+        entry.onClick = spec.onClick ?? entry.onClick ?? null;
+        entry.shouldShow = typeof spec.shouldShow === 'function' ? spec.shouldShow : (entry.shouldShow || null);
+        SelectionFilter._selectionActions.set(id, entry);
+        if (!SelectionFilter._selectionActionOrder.includes(id)) {
+            SelectionFilter._selectionActionOrder.push(id);
+        }
+        SelectionFilter._ensureSelectionActionListener();
+        SelectionFilter._syncSelectionActions();
+        return id;
+    }
+
+    static unregisterSelectionAction(id) {
+        if (!id) return;
+        const entry = SelectionFilter._selectionActions.get(id);
+        if (entry?.btn && entry.btn.parentNode) {
+            try { entry.btn.parentNode.removeChild(entry.btn); } catch { }
+        }
+        SelectionFilter._selectionActions.delete(id);
+        SelectionFilter._selectionActionOrder = SelectionFilter._selectionActionOrder.filter((k) => k !== id);
+        SelectionFilter._syncSelectionActions();
+    }
+
+    static refreshSelectionActions() {
+        SelectionFilter._syncSelectionActions();
+    }
+
+    static _ensureSelectionActionListener() {
+        if (SelectionFilter._selectionActionListenerBound) return;
+        if (typeof window === 'undefined') return;
+        SelectionFilter._selectionActionListenerBound = true;
+        window.addEventListener('selection-changed', () => SelectionFilter._syncSelectionActions());
+    }
+
+    static _syncSelectionActions() {
+        const actions = SelectionFilter._selectionActions;
+        if (!actions || actions.size === 0) {
+            try {
+                const bar = SelectionFilter._selectionActionBar;
+                if (bar) bar.style.display = 'none';
+            } catch { }
+            return;
+        }
+        const viewer = SelectionFilter.viewer;
+        const bar = SelectionFilter._ensureSelectionActionBar(viewer);
+        if (!bar) {
+            SelectionFilter._selectionActionsPending = true;
+            return;
+        }
+        SelectionFilter._selectionActionsPending = false;
+        const selection = SelectionFilter.getSelectedObjects();
+        const hideAll = !!viewer?._sketchMode;
+        let visibleCount = 0;
+        const updateButton = (entry, show) => {
+            if (!entry || !entry.btn) return;
+            try { entry.btn.style.display = show ? '' : 'none'; } catch { }
+            if (show) visibleCount += 1;
+        };
+        for (const id of SelectionFilter._selectionActionOrder) {
+            const entry = actions.get(id);
+            if (!entry) continue;
+            if (!entry.btn) {
+                entry.btn = SelectionFilter._createSelectionActionButton(entry);
+            }
+            if (!entry.btn) continue;
+            try {
+                entry.btn.textContent = String(entry.label ?? '');
+                entry.btn.title = String(entry.title ?? entry.label ?? '');
+                entry.btn.__sabOnClick = entry.onClick;
+                const isIcon = String(entry.label || '').length <= 2;
+                entry.btn.classList.toggle('sab-icon', isIcon);
+            } catch { }
+            let show = !hideAll;
+            if (show) {
+                if (typeof entry.shouldShow === 'function') {
+                    try { show = !!entry.shouldShow(selection, viewer); } catch { show = false; }
+                } else {
+                    show = selection.length > 0;
+                }
+            }
+            updateButton(entry, show);
+            if (entry.btn.parentNode !== bar) {
+                try { bar.appendChild(entry.btn); } catch { }
+            }
+        }
+        try {
+            if (bar) bar.style.display = visibleCount > 0 ? 'flex' : 'none';
+        } catch { }
+    }
+
+    static _ensureSelectionActionBar(viewer) {
+        if (SelectionFilter._selectionActionBar && SelectionFilter._selectionActionBar.isConnected) {
+            return SelectionFilter._selectionActionBar;
+        }
+        if (typeof document === 'undefined') return null;
+        const host = viewer?.container || document.body || null;
+        if (!host) return null;
+        try {
+            if (!document.getElementById('selection-action-bar-styles')) {
+                const style = document.createElement('style');
+                style.id = 'selection-action-bar-styles';
+                style.textContent = `
+                  .selection-action-bar {
+                    position: absolute;
+                    top: 100px;
+                    right: 8px;
+                    display: flex;
+                    flex-direction: column;
+                    gap: 6px;
+                    align-items: stretch;
+                    background: rgba(20,24,30,.85);
+                    border: 1px solid #262b36;
+                    border-radius: 8px;
+                    padding: 6px;
+                    color: #ddd;
+                    min-width: 40px;
+                    max-width: 150px;
+                    z-index: 12;
+                    user-select: none;
+                  }
+                  .selection-action-bar .sab-btn {
+                    background: transparent;
+                    border-radius: 6px;
+                    padding: 4px 8px;
+                    width: 100%;
+                    min-height: 34px;
+                    box-sizing: border-box;
+                    color: #ddd;
+                    border: 1px solid #364053;
+                    cursor: pointer;
+                  }
+                  .selection-action-bar .sab-btn:hover { filter: brightness(1.08); }
+                  .selection-action-bar .sab-btn:active { filter: brightness(1.15); }
+                  .selection-action-bar .sab-btn.sab-icon {
+                    font-size: 16px;
+                    min-width: 36px;
+                  }
+                `;
+                document.head.appendChild(style);
+            }
+        } catch { }
+        const bar = document.createElement('div');
+        bar.className = 'selection-action-bar';
+        host.appendChild(bar);
+        SelectionFilter._selectionActionBar = bar;
+        return bar;
+    }
+
+    static _createSelectionActionButton(entry) {
+        try {
+            const btn = document.createElement('button');
+            btn.className = 'sab-btn';
+            btn.textContent = String(entry?.label ?? '');
+            btn.title = String(entry?.title ?? entry?.label ?? '');
+            btn.__sabOnClick = entry?.onClick ?? null;
+            btn.addEventListener('click', (e) => {
+                e.stopPropagation();
+                try { btn.__sabOnClick && btn.__sabOnClick(); } catch { }
+            });
+            const isIcon = String(entry?.label || '').length <= 2;
+            if (isIcon) btn.classList.add('sab-icon');
+            return btn;
+        } catch { return null; }
+    }
+
     static #logAllowedTypesChange(next, reason = '') {
         try {
             const desc = next === SelectionFilter.ALL

package/src/UI/featureDialogWidgets/booleanOperationField.js

@@ -1,9 +1,11 @@
+import { renderReferenceSelectionField } from './referenceSelectionField.js';
+
 export function renderBooleanOperationField({ ui, key, def, controlWrap }) {
     if (!ui.params[key] || typeof ui.params[key] !== 'object') {
-        ui.params[key] = { targets: [], operation: 'NONE', operation: 'NONE' };
+        ui.params[key] = { targets: [], operation: 'NONE' };
     } else {
         if (!Array.isArray(ui.params[key].targets)) ui.params[key].targets = [];
-        if (!ui.params[key].operation && !ui.params[key].operation) ui.params[key].operation = 'NONE';
+        if (!ui.params[key].operation) ui.params[key].operation = 'NONE';
     }
 
     const wrap = document.createElement('div');
@@ -19,70 +21,49 @@ export function renderBooleanOperationField({ ui, key, def, controlWrap }) {
         opt.textContent = String(op);
         sel.appendChild(opt);
     }
-    sel.value = String((ui.params[key].operation ?? ui.params[key].operation) || 'NONE');
+    sel.value = String(ui.params[key].operation || 'NONE');
     sel.addEventListener('change', () => {
         if (!ui.params[key] || typeof ui.params[key] !== 'object') ui.params[key] = { targets: [], operation: 'NONE' };
         ui.params[key].operation = sel.value;
-        ui.params[key].operation = sel.value;
         ui._emitParamsChange(key, ui.params[key]);
     });
     wrap.appendChild(sel);
 
-    const refWrap = document.createElement('div');
-    refWrap.className = 'ref-multi-wrap';
-    const chipsWrap = document.createElement('div');
-    chipsWrap.className = 'ref-chips';
-    refWrap.appendChild(chipsWrap);
-
-    const inputElTargets = document.createElement('input');
-    inputElTargets.type = 'text';
-    inputElTargets.className = 'input';
-    inputElTargets.dataset.multiple = 'true';
-    inputElTargets.placeholder = 'Click then select solids…';
-    ui._renderChips(chipsWrap, key, Array.isArray(ui.params[key].targets) ? ui.params[key].targets : []);
-
-    const activate = () => {
-        ui._activateReferenceSelection(inputElTargets, { selectionFilter: ['SOLID'] });
+    const refMount = document.createElement('div');
+    const targetsDef = {
+        type: 'reference_selection',
+        multiple: true,
+        selectionFilter: ['SOLID'],
     };
-    chipsWrap.addEventListener('click', activate);
-    inputElTargets.addEventListener('click', activate);
-
-    inputElTargets.addEventListener('change', () => {
-        if (inputElTargets.dataset && inputElTargets.dataset.forceClear === 'true') {
-            if (!ui.params[key] || typeof ui.params[key] !== 'object') ui.params[key] = { targets: [], operation: 'NONE' };
-            ui.params[key].targets = [];
-            ui._renderChips(chipsWrap, key, ui.params[key].targets);
-            inputElTargets.value = '';
-            delete inputElTargets.dataset.forceClear;
+    const valueAdapter = {
+        read: () => {
+            const current = ui.params[key];
+            if (!current || typeof current !== 'object') return [];
+            return Array.isArray(current.targets) ? current.targets : [];
+        },
+        write: (next) => {
+            if (!ui.params[key] || typeof ui.params[key] !== 'object') ui.params[key] = { targets: [], operation: sel.value || 'NONE' };
+            ui.params[key].targets = Array.isArray(next) ? next : [];
+        },
+        emit: () => {
             ui._emitParamsChange(key, ui.params[key]);
-            return;
-        }
-        if (!ui.params[key] || typeof ui.params[key] !== 'object') ui.params[key] = { targets: [], operation: 'NONE' };
-        let incoming = [];
-        try {
-            const parsed = JSON.parse(inputElTargets.value);
-            if (Array.isArray(parsed)) incoming = parsed;
-        } catch (_) {
-            if (inputElTargets.value && String(inputElTargets.value).trim() !== '') incoming = [String(inputElTargets.value).trim()];
-        }
-        const cur = Array.isArray(ui.params[key].targets) ? ui.params[key].targets : [];
-        for (const name of incoming) {
-            if (!cur.includes(name)) cur.push(name);
-        }
-        ui.params[key].targets = cur;
-        ui._renderChips(chipsWrap, key, cur);
-        inputElTargets.value = '';
-        ui._emitParamsChange(key, ui.params[key]);
+        },
+    };
+    const refField = renderReferenceSelectionField({
+        ui,
+        key,
+        def: targetsDef,
+        id: `${key}-targets`,
+        controlWrap: refMount,
+        valueAdapter,
     });
-
-    refWrap.appendChild(inputElTargets);
-    wrap.appendChild(refWrap);
+    wrap.appendChild(refMount);
 
     controlWrap.appendChild(wrap);
 
     return {
-        inputEl: inputElTargets,
-        activate,
+        inputEl: refField.inputEl,
+        activate: refField.activate,
         readValue() {
             const current = ui.params[key];
             if (!current || typeof current !== 'object') {

package/src/UI/featureDialogWidgets/referenceSelectionField.js

@@ -5,6 +5,7 @@ export function renderReferenceSelectionField({ ui, key, def, id, controlWrap, v
     inputEl.type = 'hidden';
     inputEl.id = id;
     try { inputEl.dataset.key = String(key); } catch (_) { }
+    try { inputEl.__refSelectionDef = def; } catch (_) { }
 
     const isMulti = !!def.multiple;
     if (isMulti) inputEl.dataset.multiple = 'true';
@@ -132,6 +133,15 @@ export function renderReferenceSelectionField({ ui, key, def, id, controlWrap, v
         inputEl.value = initial ?? '';
 
         valueWrap.addEventListener('click', () => ui._activateReferenceSelection(inputEl, def));
+        valueWrap.addEventListener('mouseenter', () => {
+            const normalized = normalizeReferenceName(inputEl.value || readRawValue());
+            if (normalized) {
+                try { ui._hoverReferenceSelectionItem?.(inputEl, def, normalized); } catch (_) { }
+            }
+        });
+        valueWrap.addEventListener('mouseleave', () => {
+            try { ui._clearReferenceSelectionHover?.(inputEl); } catch (_) { }
+        });
         refWrap.appendChild(valueWrap);
 
         inputEl.addEventListener('change', () => {