brep-io-kernel 1.0.0-ci.10

package/src/UI/assembly/constraintFaceUtils.js

@@ -0,0 +1,115 @@
+import * as THREE from 'three';
+import { objectRepresentativePoint } from '../pmi/annUtils.js';
+
+export function isFaceObject(object) {
+  if (!object) return false;
+  const type = object.userData?.type || object.userData?.brepType || object.type;
+  return String(type).toUpperCase() === 'FACE';
+}
+
+export function computeFaceOrigin(object) {
+  if (!object) return null;
+  try {
+    const pt = objectRepresentativePoint?.(null, object);
+    if (pt && typeof pt.clone === 'function') return pt.clone();
+  } catch { /* ignore */ }
+
+  const geom = object.geometry;
+  if (geom?.computeBoundingBox) {
+    try {
+      geom.computeBoundingBox();
+      const center = geom.boundingBox?.getCenter(new THREE.Vector3());
+      if (center) {
+        object.updateMatrixWorld?.(true);
+        return center.applyMatrix4(object.matrixWorld);
+      }
+    } catch { /* ignore */ }
+  }
+
+  if (typeof object.getWorldPosition === 'function') {
+    try {
+      return object.getWorldPosition(new THREE.Vector3());
+    } catch { /* ignore */ }
+  }
+
+  return null;
+}
+
+export function computeFaceNormal(object) {
+  if (!object) return null;
+  try {
+    if (typeof object.getAverageNormal === 'function') {
+      const avg = object.getAverageNormal();
+      if (avg && avg.lengthSq() > 1e-10) return avg.clone().normalize();
+    }
+  } catch { /* ignore */ }
+
+  const geom = object.geometry;
+  if (!geom?.isBufferGeometry) return null;
+  const pos = geom.getAttribute?.('position');
+  if (!pos || pos.itemSize !== 3 || pos.count < 3) return null;
+  const index = geom.getIndex?.();
+
+  const v0 = new THREE.Vector3();
+  const v1 = new THREE.Vector3();
+  const v2 = new THREE.Vector3();
+  const edge1 = new THREE.Vector3();
+  const edge2 = new THREE.Vector3();
+  const accum = new THREE.Vector3();
+
+  object.updateMatrixWorld?.(true);
+
+  const triCount = index ? Math.floor(index.count / 3) : Math.floor(pos.count / 3);
+  const samples = Math.min(triCount, 60);
+  let count = 0;
+
+  for (let tri = 0; tri < samples; tri += 1) {
+    let i0;
+    let i1;
+    let i2;
+
+    if (index) {
+      const base = tri * 3;
+      if (base + 2 >= index.count) break;
+      i0 = index.getX(base);
+      i1 = index.getX(base + 1);
+      i2 = index.getX(base + 2);
+    } else {
+      i0 = tri * 3;
+      i1 = i0 + 1;
+      i2 = i0 + 2;
+      if (i2 >= pos.count) break;
+    }
+
+    v0.set(pos.getX(i0), pos.getY(i0), pos.getZ(i0)).applyMatrix4(object.matrixWorld);
+    v1.set(pos.getX(i1), pos.getY(i1), pos.getZ(i1)).applyMatrix4(object.matrixWorld);
+    v2.set(pos.getX(i2), pos.getY(i2), pos.getZ(i2)).applyMatrix4(object.matrixWorld);
+
+    edge1.subVectors(v1, v0);
+    edge2.subVectors(v2, v0);
+    const normal = new THREE.Vector3().crossVectors(edge1, edge2);
+    if (normal.lengthSq() > 1e-10) {
+      accum.add(normal);
+      count += 1;
+    }
+  }
+
+  if (count === 0) return null;
+
+  accum.divideScalar(count);
+  if (accum.lengthSq() <= 1e-10) return null;
+
+  return accum.normalize();
+}
+
+export function estimateArrowLength(object) {
+  const geom = object?.geometry;
+  if (geom?.computeBoundingSphere) {
+    try {
+      geom.computeBoundingSphere();
+      const radius = geom.boundingSphere?.radius;
+      if (Number.isFinite(radius) && radius > 0) return Math.max(radius, 10);
+    } catch { /* ignore */ }
+  }
+  return 10;
+}

package/src/UI/assembly/constraintHighlightUtils.js

@@ -0,0 +1,70 @@
+export function applyHighlightMaterial(object, color, store, skipSets = [store]) {
+  if (!object || !color || !store) return false;
+
+  const guardSets = Array.isArray(skipSets)
+    ? skipSets.filter((m) => m && typeof m.has === 'function')
+    : [];
+  if (guardSets.length === 0) guardSets.push(store);
+
+  const targets = [];
+  object.traverse?.((child) => {
+    if (!child || !child.isObject3D) return;
+    if (child.material && child.material.color) targets.push(child);
+  });
+  if (targets.length === 0 && object.material && object.material.color) {
+    targets.push(object);
+  }
+
+  let modified = false;
+  for (const target of targets) {
+    const key = target.uuid;
+    if (guardSets.some((map) => map.has(key))) continue;
+
+    const originalMaterial = target.material;
+    let replaced = false;
+    let highlightMaterial = originalMaterial;
+    if (originalMaterial && typeof originalMaterial.clone === 'function') {
+      try {
+        const clone = originalMaterial.clone();
+        if (clone) {
+          highlightMaterial = clone;
+          replaced = clone !== originalMaterial;
+        }
+      } catch { /* ignore */ }
+    }
+
+    const previousColor = (!replaced && highlightMaterial?.color && highlightMaterial.color.clone)
+      ? highlightMaterial.color.clone()
+      : null;
+
+    try { highlightMaterial?.color?.set(color); } catch { /* ignore */ }
+
+    if (replaced) {
+      target.material = highlightMaterial;
+    }
+
+    store.set(key, {
+      object: target,
+      replaced,
+      originalMaterial,
+      previousColor,
+    });
+    modified = true;
+  }
+
+  return modified;
+}
+
+export function restoreHighlightRecords(map) {
+  if (!map || typeof map.size !== 'number' || map.size === 0) return;
+  for (const record of map.values()) {
+    try {
+      if (record.replaced && record.originalMaterial) {
+        record.object.material = record.originalMaterial;
+      } else if (record.previousColor && record.object.material?.color) {
+        record.object.material.color.copy(record.previousColor);
+      }
+    } catch { /* ignore */ }
+  }
+  map.clear();
+}

package/src/UI/assembly/constraintLabelUtils.js

@@ -0,0 +1,31 @@
+import { evaluateConstraintNumericValue } from '../../assemblyConstraints/constraintExpressionUtils.js';
+
+export function constraintLabelText(entry, constraintClass, partHistory = null) {
+  const cls = constraintClass || entry?.constraintClass || null;
+  const rawShortName = cls?.shortName || cls?.constraintShortName;
+  const shortName = rawShortName != null ? String(rawShortName).trim() : '';
+  const base = shortName
+    || cls?.longName
+    || cls?.constraintName
+    || entry?.constraintType
+    || entry?.type
+    || 'Constraint';
+
+  let distanceSuffix = '';
+  let angleSuffix = '';
+  if (entry?.type === 'distance' || cls?.constraintType === 'distance') {
+    const distance = evaluateConstraintNumericValue(partHistory, entry?.inputParams?.distance);
+    if (distance != null) distanceSuffix = String(distance);
+  }
+  if (entry?.type === 'angle' || cls?.constraintType === 'angle') {
+    const angle = evaluateConstraintNumericValue(partHistory, entry?.inputParams?.angle);
+    if (angle != null) angleSuffix = `${angle}°`;
+  }
+
+  const parts = [];
+  if (base) parts.push(String(base).trim());
+  if (distanceSuffix) parts.push(distanceSuffix);
+  if (angleSuffix) parts.push(angleSuffix);
+
+  return parts.join(' ').trim();
+}

package/src/UI/assembly/constraintPointUtils.js

@@ -0,0 +1,64 @@
+import * as THREE from 'three';
+import { objectRepresentativePoint } from '../pmi/annUtils.js';
+
+export function extractWorldPoint(object) {
+  if (!object) return null;
+  try { object.updateMatrixWorld?.(true); }
+  catch { /* ignore */ }
+
+  try {
+    if (typeof object.type === 'string'
+      && object.type.toUpperCase() === 'EDGE'
+      && typeof object.points === 'function') {
+      const pts = object.points(true);
+      if (Array.isArray(pts) && pts.length) {
+        const total = new THREE.Vector3();
+        let count = 0;
+        for (const pt of pts) {
+          if (!pt) continue;
+          const x = Number(pt.x);
+          const y = Number(pt.y);
+          const z = Number(pt.z);
+          if ([x, y, z].some((v) => !Number.isFinite(v))) continue;
+          total.add(new THREE.Vector3(x, y, z));
+          count += 1;
+        }
+        if (count > 0) {
+          total.divideScalar(count);
+          return total;
+        }
+      }
+    }
+  } catch { /* ignore */ }
+
+  try {
+    const rep = objectRepresentativePoint?.(null, object);
+    if (rep && typeof rep.clone === 'function') return rep.clone();
+    if (rep && rep.isVector3) return rep.clone();
+  } catch { /* ignore */ }
+
+  try {
+    if (typeof object.getWorldPosition === 'function') {
+      return object.getWorldPosition(new THREE.Vector3());
+    }
+  } catch { /* ignore */ }
+
+  try {
+    if (object.isVector3) return object.clone();
+  } catch { /* ignore */ }
+
+  try {
+    if (object.position) {
+      const pos = object.position.clone
+        ? object.position.clone()
+        : new THREE.Vector3(object.position.x, object.position.y, object.position.z);
+      if (object.parent?.matrixWorld) {
+        object.parent.updateMatrixWorld?.(true);
+        return pos.applyMatrix4(object.parent.matrixWorld);
+      }
+      return pos;
+    }
+  } catch { /* ignore */ }
+
+  return null;
+}

package/src/UI/assembly/constraintSelectionUtils.js

@@ -0,0 +1,185 @@
+export function resolveSelectionObject(scene, selection, options = {}) {
+  const scoreFn = typeof options.scoreFn === 'function' ? options.scoreFn : scoreObjectForNormal;
+  return internalResolveSelectionObject(scene, selection, { scoreFn });
+}
+
+function internalResolveSelectionObject(scene, selection, options) {
+  if (!scene || selection == null) return null;
+  if (selection.isObject3D) return selection;
+
+  if (Array.isArray(selection)) {
+    for (const item of selection) {
+      const resolved = internalResolveSelectionObject(scene, item, options);
+      if (resolved) return resolved;
+    }
+    return null;
+  }
+
+  if (typeof selection === 'string') {
+    return resolveObjectFromString(scene, selection, options);
+  }
+
+  if (typeof selection === 'object') {
+    if (selection.isObject3D) return selection;
+    const {
+      uuid,
+      name,
+      id,
+      path,
+      reference,
+      target,
+    } = selection;
+
+    if (typeof uuid === 'string') {
+      try {
+        const found = scene.getObjectByProperty?.('uuid', uuid);
+        if (found) return found;
+      } catch { /* ignore */ }
+    }
+
+    const resolveCandidate = (candidate) => (
+      typeof candidate === 'string'
+        ? resolveObjectFromString(scene, candidate, options)
+        : null
+    );
+
+    const nameCandidate = typeof name === 'string'
+      ? name
+      : (typeof selection?.selectionName === 'string' ? selection.selectionName : null);
+    const idCandidate = typeof id === 'string' ? id : null;
+
+    const nameResolved = resolveCandidate(nameCandidate);
+    if (nameResolved) return nameResolved;
+
+    const idResolved = resolveCandidate(idCandidate);
+    if (idResolved) return idResolved;
+
+    if (Array.isArray(path)) {
+      for (let i = path.length - 1; i >= 0; i -= 1) {
+        const segment = path[i];
+        if (typeof segment !== 'string') continue;
+        const resolved = resolveObjectFromString(scene, segment, options);
+        if (resolved) return resolved;
+      }
+    }
+
+    if (reference != null) {
+      const resolved = internalResolveSelectionObject(scene, reference, options);
+      if (resolved) return resolved;
+    }
+
+    if (target != null) {
+      const resolved = internalResolveSelectionObject(scene, target, options);
+      if (resolved) return resolved;
+    }
+  }
+
+  return null;
+}
+
+function resolveObjectFromString(scene, value, options) {
+  if (!scene || typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+
+  if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed != null) {
+        const resolved = internalResolveSelectionObject(scene, parsed, options);
+        if (resolved) return resolved;
+      }
+    } catch { /* ignore JSON parse errors */ }
+  }
+
+  const direct = findObjectByName(scene, trimmed, options.scoreFn);
+  if (direct) return direct;
+
+  if (looksLikeUUID(trimmed)) {
+    try {
+      const byUuid = scene.getObjectByProperty?.('uuid', trimmed);
+      if (byUuid) return byUuid;
+    } catch { /* ignore */ }
+  }
+
+  const candidates = new Set();
+  candidates.add(trimmed);
+
+  const splitByDelims = trimmed.split(/›|>|\/|\||→|->/);
+  if (splitByDelims.length > 1) {
+    for (const segment of splitByDelims) {
+      const s = segment.trim();
+      if (s) candidates.add(s);
+    }
+  }
+
+  if (trimmed.includes(':')) {
+    for (const segment of trimmed.split(':')) {
+      const s = segment.trim();
+      if (s) candidates.add(s);
+    }
+  }
+
+  for (const candidate of candidates) {
+    const found = findObjectByName(scene, candidate, options.scoreFn);
+    if (found) return found;
+  }
+
+  let fallback = null;
+  try {
+    scene.traverse?.((obj) => {
+      if (fallback || !obj?.name) return;
+      if (!trimmed.includes(obj.name)) return;
+      if (!fallback) {
+        fallback = obj;
+        return;
+      }
+      const currentScore = options.scoreFn(fallback);
+      const nextScore = options.scoreFn(obj);
+      if (nextScore > currentScore || obj.name.length > fallback.name.length) {
+        fallback = obj;
+      }
+    });
+  } catch { /* ignore */ }
+
+  return fallback;
+}
+
+function findObjectByName(scene, name, scoreFn) {
+  if (!scene || typeof name !== 'string' || !name) return null;
+
+  if (typeof scene.traverse !== 'function') {
+    return scene?.getObjectByName?.(name) || null;
+  }
+
+  let best = null;
+  scene.traverse((obj) => {
+    if (!obj || obj.name !== name) return;
+    if (!best) {
+      best = obj;
+      return;
+    }
+    const currentScore = scoreFn(best);
+    const newScore = scoreFn(obj);
+    if (newScore > currentScore) best = obj;
+  });
+
+  if (best) return best;
+  if (typeof scene.getObjectByName === 'function') return scene.getObjectByName(name);
+  return null;
+}
+
+function looksLikeUUID(value) {
+  if (typeof value !== 'string') return false;
+  const trimmed = value.trim();
+  if (trimmed.length !== 36) return false;
+  return /^[0-9a-fA-F-]{36}$/.test(trimmed);
+}
+
+function scoreObjectForNormal(object) {
+  if (!object) return -Infinity;
+  const type = object.userData?.type || object.userData?.brepType || object.type;
+  if (String(type).toUpperCase() === 'FACE') return 3;
+  if (object.geometry) return 2;
+  return 1;
+}

package/src/UI/assembly/constraintStatusUtils.js

@@ -0,0 +1,142 @@
+export function constraintStatusInfo(entry) {
+  const pd = entry?.persistentData || {};
+  const status = pd.status || 'Idle';
+  const isDisabled = entry?.enabled === false || status === 'disabled';
+  const out = { label: '', title: '', error: false, color: '#ffd60a' };
+
+  if (isDisabled) {
+    out.label = 'Disabled';
+    out.title = pd.message || 'Constraint disabled.';
+    out.color = '#8e8e93';
+    return out;
+  }
+
+  if (status === 'unimplemented') {
+    out.label = 'Unimplemented';
+    out.title = pd.message || 'Constraint solver not implemented yet.';
+    out.error = true;
+    out.color = '#ff3b30';
+    return out;
+  }
+
+  if (status === 'satisfied') {
+    out.label = 'Satisfied';
+    out.title = pd.message || 'Constraint satisfied within tolerance.';
+    out.color = '#30d158';
+    return out;
+  }
+
+  if (status === 'adjusted') {
+    out.label = 'Adjusting';
+    out.title = pd.message || 'Constraint nudging components toward the solution.';
+    out.color = '#ffd60a';
+    return out;
+  }
+
+  if (status === 'adjusting') {
+    out.label = 'Adjusting';
+    out.title = pd.message || 'Constraint nudging components toward the solution.';
+    out.color = '#ffd60a';
+    return out;
+  }
+
+  if (status === 'blocked') {
+    out.label = 'Blocked';
+    out.title = pd.message || 'Constraint cannot adjust locked components.';
+    out.error = true;
+    out.color = '#ff3b30';
+    return out;
+  }
+
+  if (status === 'pending') {
+    out.label = 'Pending';
+    out.title = pd.message || 'Constraint awaiting convergence.';
+    return out;
+  }
+
+  if (status === 'duplicate') {
+    out.label = 'Duplicate';
+    out.title = pd.message || 'Another constraint uses the same selections.';
+    out.error = true;
+    out.color = '#ff3b30';
+    return out;
+  }
+
+  if (status === 'error') {
+    out.label = 'Error';
+    out.title = pd.message || 'Constraint evaluation failed.';
+    out.error = true;
+    out.color = '#ff3b30';
+    return out;
+  }
+
+  if (status === 'applied' || status === 'computed') {
+    const delta = Array.isArray(pd.lastDelta)
+      ? pd.lastDelta.map((v) => Number(v).toFixed(3)).join(', ')
+      : null;
+    out.label = status === 'applied' ? 'Applied' : 'Pending';
+    if (delta) out.label += ` · Δ[${delta}]`;
+    if (Array.isArray(pd.lastAppliedMoves) && pd.lastAppliedMoves.length) {
+      const summary = pd.lastAppliedMoves
+        .map((move) => {
+          if (!move || !Array.isArray(move.move)) return null;
+          const vec = move.move.map((v) => Number(v).toFixed(3)).join(', ');
+          return `${move.element}: [${vec}]`;
+        })
+        .filter(Boolean)
+        .join(' | ');
+      if (summary) out.title = summary;
+    }
+    return out;
+  }
+
+  if (status === 'incomplete') {
+    out.label = 'Incomplete';
+    out.title = 'Select the required components to define the constraint.';
+    return out;
+  }
+
+  if (status === 'invalid-selection') {
+    out.label = 'Invalid selection';
+    out.title = 'Unable to resolve world positions for selections.';
+    out.error = true;
+    return out;
+  }
+
+  if (status === 'pending-component') {
+    out.label = 'Pending component';
+    out.title = 'Offset stored but no component selected to move.';
+    return out;
+  }
+
+  if (status === 'fixed') {
+    out.label = 'Locked';
+    out.title = pd.message || 'Both components are fixed; nothing moved.';
+    return out;
+  }
+
+  if (status === 'noop') {
+    out.label = 'No change';
+    out.title = pd.message || 'Selections already satisfy this constraint.';
+    return out;
+  }
+
+  if (status === 'apply-failed') {
+    out.label = 'Failed';
+    out.title = pd.error || 'Apply failed';
+    out.error = true;
+    out.color = '#ff3b30';
+    return out;
+  }
+
+  if (status && status !== 'Idle') {
+    out.label = status.charAt(0).toUpperCase() + status.slice(1);
+    if (pd.message) out.title = pd.message;
+  }
+
+  if (out.error && !out.color) {
+    out.color = '#ff3b30';
+  }
+
+  return out;
+}