brep-io-kernel 1.0.0-ci.10

package/src/assemblyConstraints/AssemblyConstraintRegistry.js

@@ -0,0 +1,120 @@
+import { AngleConstraint } from './constraints/AngleConstraint.js';
+import { CoincidentConstraint } from './constraints/CoincidentConstraint.js';
+import { DistanceConstraint } from './constraints/DistanceConstraint.js';
+import { FixedConstraint } from './constraints/FixedConstraint.js';
+import { ParallelConstraint } from './constraints/ParallelConstraint.js';
+import { TouchAlignConstraint } from './constraints/TouchAlignConstraint.js';
+
+const normalizeName = (value) => {
+  if (value == null && value !== 0) return '';
+  try {
+    return String(value).trim();
+  } catch {
+    return '';
+  }
+};
+
+const normalizeKey = (value) => normalizeName(value).toLowerCase();
+
+const getShortName = (ConstraintClass) => normalizeName(
+  ConstraintClass?.shortName
+  ?? ConstraintClass?.constraintShortName
+  ?? ConstraintClass?.name,
+);
+
+const getLongName = (ConstraintClass) => normalizeName(
+  ConstraintClass?.longName
+  ?? ConstraintClass?.constraintName
+  ?? ConstraintClass?.name,
+);
+
+export class AssemblyConstraintRegistry {
+  constructor() {
+    this._map = new Map();
+    this._aliases = new Map();
+
+    // Register built-ins immediately.
+    this.register(CoincidentConstraint);
+    this.register(AngleConstraint);
+    this.register(DistanceConstraint);
+    this.register(FixedConstraint);
+    this.register(ParallelConstraint);
+    this.register(TouchAlignConstraint);
+  }
+
+  /**
+   * Register a constraint class. Keys derive from `constraintType`, `shortName`, etc.
+   * @param {typeof import('./BaseAssemblyConstraint.js').BaseAssemblyConstraint} ConstraintClass
+   */
+  register(ConstraintClass) {
+    if (!ConstraintClass) return;
+    if (!ConstraintClass.shortName) {
+      ConstraintClass.shortName = ConstraintClass.constraintShortName || ConstraintClass.name || 'CONST';
+    }
+    if (!ConstraintClass.longName) {
+      ConstraintClass.longName = ConstraintClass.constraintName || ConstraintClass.name || ConstraintClass.shortName || 'Constraint';
+    }
+    const keys = this.#collectKeys(ConstraintClass);
+    if (!keys.typeKey) return;
+
+    this._map.set(keys.typeKey, ConstraintClass);
+    for (const alias of keys.aliases) {
+      const aliasKey = normalizeKey(alias);
+      if (aliasKey) this._aliases.set(aliasKey, ConstraintClass);
+    }
+  }
+
+  get(name) {
+    const key = normalizeKey(name);
+    if (!key) {
+      throw new Error('Constraint type must be a non-empty string');
+    }
+    const cls = this._map.get(key) || this._aliases.get(key);
+    if (!cls) {
+      throw new Error(`Constraint type "${name}" is not registered.`);
+    }
+    return cls;
+  }
+
+  getSafe(name) {
+    try {
+      return this.get(name);
+    } catch {
+      return null;
+    }
+  }
+
+  has(name) {
+    return !!this.getSafe(name);
+  }
+
+  list() {
+    return Array.from(new Set(this._map.values()));
+  }
+
+  listAvailable() {
+    return this.list();
+  }
+
+  #collectKeys(ConstraintClass) {
+    const keys = new Set();
+    const type = normalizeKey(ConstraintClass.constraintType || ConstraintClass.type || null);
+    if (type) keys.add(type);
+
+    const shortName = normalizeKey(getShortName(ConstraintClass));
+    if (shortName && shortName !== type) keys.add(shortName);
+
+    const longName = normalizeKey(getLongName(ConstraintClass));
+    if (longName && longName !== type) keys.add(longName);
+
+    const className = normalizeKey(ConstraintClass.name);
+    if (className) keys.add(className);
+
+    const aliases = Array.isArray(ConstraintClass.aliases)
+      ? ConstraintClass.aliases.filter(Boolean)
+      : [];
+
+    const [typeKey, ...rest] = keys;
+    return { typeKey: typeKey || null, aliases: rest.concat(aliases) };
+  }
+}

package/src/assemblyConstraints/BaseAssemblyConstraint.js

@@ -0,0 +1,66 @@
+import * as THREE from 'three';
+
+/**
+ * Base class for all assembly constraints. Mirrors the feature/annotation patterns:
+ *  - subclasses define static metadata (shortName, longName, constraintType)
+ *  - subclasses provide a static inputParamsSchema compatible with SchemaForm
+ *  - instances expose `inputParams` and `persistentData` containers updated by the UI/runtime
+ */
+export class BaseAssemblyConstraint {
+  static shortName = 'ACON';
+  static longName = 'Assembly Constraint';
+  static constraintType = 'assembly_constraint';
+  static inputParamsSchema = {
+    id: {
+      type: 'string',
+      default_value: null,
+      hint: 'Unique identifier for the constraint.',
+    },
+  };
+
+  constructor(partHistory = null) {
+    this.partHistory = partHistory;
+    this.inputParams = {};
+    this.persistentData = {};
+  }
+
+  /**
+   * Convenience accessor for subclasses: tries to resolve a world-space position for a selection.
+   * @param {THREE.Object3D|undefined|null} obj
+   * @returns {THREE.Vector3|null}
+   */
+  getWorldPoint(obj) {
+    if (!obj) return null;
+    try {
+      const target = new THREE.Vector3();
+      if (typeof obj.getWorldPosition === 'function') {
+        obj.getWorldPosition(target);
+        return target;
+      }
+      if (obj.isVector3) {
+        return obj.clone();
+      }
+      if (obj.position) {
+        target.copy(obj.position);
+        if (obj.parent && obj.parent.isObject3D) {
+          obj.parent.updateMatrixWorld?.(true);
+          target.applyMatrix4(obj.parent.matrixWorld);
+        }
+        return target;
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+
+  /**
+   * Subclasses override to implement the constraint behaviour.
+   * @param {import('../PartHistory.js').PartHistory} partHistory
+   * @returns {Promise<unknown>}
+   */
+  async run(partHistory) { // eslint-disable-line no-unused-vars
+    console.warn(`[${this.constructor.name}] run() not implemented.`);
+    return null;
+  }
+}

package/src/assemblyConstraints/constraintExpressionUtils.js

@@ -0,0 +1,35 @@
+/**
+ * Evaluate a constraint numeric parameter using the part history expressions.
+ * Returns a finite number when evaluation succeeds, otherwise null.
+ * @param {import('../PartHistory.js').PartHistory|null} partHistory
+ * @param {*} value
+ * @returns {number|null}
+ */
+export function evaluateConstraintNumericValue(partHistory, value) {
+  if (value == null) return null;
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : null;
+  }
+
+  let result = null;
+
+  try {
+    if (partHistory && typeof partHistory.evaluateExpression === 'function') {
+      result = partHistory.evaluateExpression(value);
+    }
+  } catch {
+    result = null;
+  }
+
+  if (typeof result === 'number' && Number.isFinite(result)) {
+    return result;
+  }
+
+  const numericFromResult = Number(result);
+  if (Number.isFinite(numericFromResult)) {
+    return numericFromResult;
+  }
+
+  const fallback = Number(value);
+  return Number.isFinite(fallback) ? fallback : null;
+}